This source file includes following definitions.
- Receive
- Send
- GetLastErrorMessage
- Create
#include "device/bluetooth/bluetooth_socket_chromeos.h"
#include <errno.h>
#include <poll.h>
#include <unistd.h>
#include <sys/ioctl.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <string>
#include "base/logging.h"
#include "base/memory/ref_counted.h"
#include "base/posix/eintr_wrapper.h"
#include "base/safe_strerror_posix.h"
#include "base/threading/thread_restrictions.h"
#include "dbus/file_descriptor.h"
#include "device/bluetooth/bluetooth_socket.h"
#include "net/base/io_buffer.h"
namespace chromeos {
BluetoothSocketChromeOS::BluetoothSocketChromeOS(int fd)
: fd_(fd) {
int optval;
socklen_t opt_len = sizeof optval;
if (getsockopt(fd_, SOL_SOCKET, SO_TYPE, &optval, &opt_len) < 0) {
LOG(WARNING) << "Unable to get socket type: " << safe_strerror(errno);
optval = SOCK_SEQPACKET;
}
if (optval == SOCK_DGRAM || optval == SOCK_SEQPACKET) {
socket_type_ = L2CAP;
} else {
socket_type_ = RFCOMM;
}
}
BluetoothSocketChromeOS::~BluetoothSocketChromeOS() {
close(fd_);
}
bool BluetoothSocketChromeOS::Receive(net::GrowableIOBuffer *buffer) {
base::ThreadRestrictions::AssertIOAllowed();
if (socket_type_ == L2CAP) {
int count;
if (ioctl(fd_, FIONREAD, &count) < 0) {
error_message_ = safe_strerror(errno);
LOG(WARNING) << "Unable to get waiting data size: " << error_message_;
return true;
}
if (count == 0) {
struct pollfd pollfd;
pollfd.fd = fd_;
pollfd.events = 0;
pollfd.revents = 0;
if (HANDLE_EINTR(poll(&pollfd, 1, 0)) < 0) {
error_message_ = safe_strerror(errno);
LOG(WARNING) << "Unable to check whether socket is closed: "
<< error_message_;
return false;
}
if (pollfd.revents & POLLHUP) {
error_message_ = "Disconnected";
return false;
}
}
buffer->SetCapacity(count);
} else {
buffer->SetCapacity(1024);
}
ssize_t bytes_read;
do {
if (buffer->RemainingCapacity() == 0)
buffer->SetCapacity(buffer->capacity() * 2);
bytes_read =
HANDLE_EINTR(read(fd_, buffer->data(), buffer->RemainingCapacity()));
if (bytes_read > 0)
buffer->set_offset(buffer->offset() + bytes_read);
} while (socket_type_ == RFCOMM && bytes_read > 0);
if (buffer->offset() > 0)
return true;
if (bytes_read < 0) {
if (errno == ECONNRESET || errno == ENOTCONN) {
error_message_ = "Disconnected";
return false;
} else if (errno != EAGAIN && errno != EWOULDBLOCK) {
error_message_ = safe_strerror(errno);
return false;
}
}
if (bytes_read == 0 && socket_type_ == RFCOMM) {
error_message_ = "Disconnected";
return false;
}
return true;
}
bool BluetoothSocketChromeOS::Send(net::DrainableIOBuffer *buffer) {
base::ThreadRestrictions::AssertIOAllowed();
ssize_t bytes_written;
do {
bytes_written =
HANDLE_EINTR(write(fd_, buffer->data(), buffer->BytesRemaining()));
if (bytes_written > 0)
buffer->DidConsume(bytes_written);
} while (buffer->BytesRemaining() > 0 && bytes_written > 0);
if (bytes_written < 0) {
if (errno == EPIPE || errno == ECONNRESET || errno == ENOTCONN) {
error_message_ = "Disconnected";
return false;
} else if (errno != EAGAIN && errno != EWOULDBLOCK) {
error_message_ = safe_strerror(errno);
return false;
}
}
return true;
}
std::string BluetoothSocketChromeOS::GetLastErrorMessage() const {
return error_message_;
}
scoped_refptr<device::BluetoothSocket> BluetoothSocketChromeOS::Create(
dbus::FileDescriptor* fd) {
DCHECK(fd->is_valid());
BluetoothSocketChromeOS* bluetooth_socket =
new BluetoothSocketChromeOS(fd->TakeValue());
return scoped_refptr<BluetoothSocketChromeOS>(bluetooth_socket);
}
}