/******************************************************************************
|
*
|
* Copyright 2013 Google, Inc.
|
*
|
* 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 "bt_snoop_net"
|
|
#include <base/logging.h>
|
#include <errno.h>
|
#include <netinet/in.h>
|
#include <pthread.h>
|
#include <stdbool.h>
|
#include <stdio.h>
|
#include <string.h>
|
#include <sys/prctl.h>
|
#include <sys/socket.h>
|
#include <sys/types.h>
|
#include <unistd.h>
|
|
#include <mutex>
|
|
#include "osi/include/log.h"
|
#include "osi/include/osi.h"
|
|
static void safe_close_(int* fd);
|
static void* listen_fn_(void* context);
|
|
static const char* LISTEN_THREAD_NAME_ = "btsnoop_net_listen";
|
static const int LOCALHOST_ = 0x7F000001;
|
static const int LISTEN_PORT_ = 8872;
|
|
static pthread_t listen_thread_;
|
static bool listen_thread_valid_ = false;
|
static std::mutex client_socket_mutex_;
|
static int listen_socket_ = -1;
|
static int client_socket_ = -1;
|
|
void btsnoop_net_open() {
|
#if (BT_NET_DEBUG != TRUE)
|
return; // Disable using network sockets for security reasons
|
#endif
|
|
listen_thread_valid_ =
|
(pthread_create(&listen_thread_, NULL, listen_fn_, NULL) == 0);
|
if (!listen_thread_valid_)
|
LOG_ERROR(LOG_TAG, "%s pthread_create failed: %s", __func__,
|
strerror(errno));
|
}
|
|
void btsnoop_net_close() {
|
#if (BT_NET_DEBUG != TRUE)
|
return; // Disable using network sockets for security reasons
|
#endif
|
|
if (listen_thread_valid_) {
|
shutdown(listen_socket_, SHUT_RDWR);
|
pthread_join(listen_thread_, NULL);
|
safe_close_(&client_socket_);
|
listen_thread_valid_ = false;
|
}
|
}
|
|
void btsnoop_net_write(const void* data, size_t length) {
|
#if (BT_NET_DEBUG != TRUE)
|
return; // Disable using network sockets for security reasons
|
#endif
|
|
std::lock_guard<std::mutex> lock(client_socket_mutex_);
|
if (client_socket_ != -1) {
|
ssize_t ret;
|
OSI_NO_INTR(ret = send(client_socket_, data, length, 0));
|
|
if (ret == -1 && errno == ECONNRESET) {
|
safe_close_(&client_socket_);
|
}
|
}
|
}
|
|
static void* listen_fn_(UNUSED_ATTR void* context) {
|
int enable = 1;
|
|
prctl(PR_SET_NAME, (unsigned long)LISTEN_THREAD_NAME_, 0, 0, 0);
|
|
listen_socket_ = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP);
|
if (listen_socket_ == -1) {
|
LOG_ERROR(LOG_TAG, "%s socket creation failed: %s", __func__,
|
strerror(errno));
|
goto cleanup;
|
}
|
|
if (setsockopt(listen_socket_, SOL_SOCKET, SO_REUSEADDR, &enable,
|
sizeof(enable)) == -1) {
|
LOG_ERROR(LOG_TAG, "%s unable to set SO_REUSEADDR: %s", __func__,
|
strerror(errno));
|
goto cleanup;
|
}
|
|
struct sockaddr_in addr;
|
addr.sin_family = AF_INET;
|
addr.sin_addr.s_addr = htonl(LOCALHOST_);
|
addr.sin_port = htons(LISTEN_PORT_);
|
if (bind(listen_socket_, (struct sockaddr*)&addr, sizeof(addr)) == -1) {
|
LOG_ERROR(LOG_TAG, "%s unable to bind listen socket: %s", __func__,
|
strerror(errno));
|
goto cleanup;
|
}
|
|
if (listen(listen_socket_, 10) == -1) {
|
LOG_ERROR(LOG_TAG, "%s unable to listen: %s", __func__, strerror(errno));
|
goto cleanup;
|
}
|
|
for (;;) {
|
int client_socket;
|
OSI_NO_INTR(client_socket = accept(listen_socket_, NULL, NULL));
|
if (client_socket == -1) {
|
if (errno == EINVAL || errno == EBADF) {
|
break;
|
}
|
LOG_WARN(LOG_TAG, "%s error accepting socket: %s", __func__,
|
strerror(errno));
|
continue;
|
}
|
|
/* When a new client connects, we have to send the btsnoop file header. This
|
* allows a decoder to treat the session as a new, valid btsnoop file. */
|
std::lock_guard<std::mutex> lock(client_socket_mutex_);
|
safe_close_(&client_socket_);
|
client_socket_ = client_socket;
|
|
OSI_NO_INTR(send(client_socket_, "btsnoop\0\0\0\0\1\0\0\x3\xea", 16, 0));
|
}
|
|
cleanup:
|
safe_close_(&listen_socket_);
|
return NULL;
|
}
|
|
static void safe_close_(int* fd) {
|
CHECK(fd != NULL);
|
if (*fd != -1) {
|
close(*fd);
|
*fd = -1;
|
}
|
}
|
