mbed-os/features/netsocket/TCPSocket.cpp

308 lines
7.8 KiB
C++

/* Socket
* Copyright (c) 2015 ARM Limited
*
* 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 "TCPSocket.h"
#include "Timer.h"
#include "mbed_assert.h"
TCPSocket::TCPSocket()
{
}
TCPSocket::~TCPSocket()
{
close();
}
nsapi_protocol_t TCPSocket::get_proto()
{
return NSAPI_TCP;
}
nsapi_error_t TCPSocket::connect(const SocketAddress &address)
{
_lock.lock();
nsapi_error_t ret;
// If this assert is hit then there are two threads
// performing a send at the same time which is undefined
// behavior
MBED_ASSERT(_writers == 0);
_writers++;
bool blocking_connect_in_progress = false;
while (true) {
if (!_socket) {
ret = NSAPI_ERROR_NO_SOCKET;
break;
}
_pending = 0;
ret = _stack->socket_connect(_socket, address);
if ((_timeout == 0) || !(ret == NSAPI_ERROR_IN_PROGRESS || ret == NSAPI_ERROR_ALREADY)) {
break;
} else {
blocking_connect_in_progress = true;
uint32_t flag;
// Release lock before blocking so other threads
// accessing this object aren't blocked
_lock.unlock();
flag = _event_flag.wait_any(WRITE_FLAG, _timeout);
_lock.lock();
if (flag & osFlagsError) {
// Timeout break
break;
}
}
}
_writers--;
if (!_socket) {
_event_flag.set(FINISHED_FLAG);
}
/* Non-blocking connect gives "EISCONN" once done - convert to OK for blocking mode if we became connected during this call */
if (ret == NSAPI_ERROR_IS_CONNECTED && blocking_connect_in_progress) {
ret = NSAPI_ERROR_OK;
}
if (ret == NSAPI_ERROR_OK || ret == NSAPI_ERROR_IN_PROGRESS) {
_remote_peer = address;
}
_lock.unlock();
return ret;
}
nsapi_error_t TCPSocket::connect(const char *host, uint16_t port)
{
SocketAddress address;
nsapi_error_t err = _stack->gethostbyname(host, &address);
if (err) {
return NSAPI_ERROR_DNS_FAILURE;
}
address.set_port(port);
// connect is thread safe
return connect(address);
}
nsapi_size_or_error_t TCPSocket::send(const void *data, nsapi_size_t size)
{
_lock.lock();
const uint8_t *data_ptr = static_cast<const uint8_t *>(data);
nsapi_size_or_error_t ret;
nsapi_size_t written = 0;
// If this assert is hit then there are two threads
// performing a send at the same time which is undefined
// behavior
MBED_ASSERT(_writers == 0);
_writers++;
// Unlike recv, we should write the whole thing if blocking. POSIX only
// allows partial as a side-effect of signal handling; it normally tries to
// write everything if blocking. Without signals we can always write all.
while (true) {
if (!_socket) {
ret = NSAPI_ERROR_NO_SOCKET;
break;
}
_pending = 0;
ret = _stack->socket_send(_socket, data_ptr + written, size - written);
if (ret >= 0) {
written += ret;
if (written >= size) {
break;
}
}
if (_timeout == 0) {
break;
} else if (ret == NSAPI_ERROR_WOULD_BLOCK) {
uint32_t flag;
// Release lock before blocking so other threads
// accessing this object aren't blocked
_lock.unlock();
flag = _event_flag.wait_any(WRITE_FLAG, _timeout);
_lock.lock();
if (flag & osFlagsError) {
// Timeout break
break;
}
} else if (ret < 0) {
break;
}
}
_writers--;
if (!_socket) {
_event_flag.set(FINISHED_FLAG);
}
_lock.unlock();
if (ret <= 0 && ret != NSAPI_ERROR_WOULD_BLOCK) {
return ret;
} else if (written == 0) {
return NSAPI_ERROR_WOULD_BLOCK;
} else {
return written;
}
}
nsapi_size_or_error_t TCPSocket::sendto(const SocketAddress &address, const void *data, nsapi_size_t size)
{
(void)address;
return send(data, size);
}
nsapi_size_or_error_t TCPSocket::recv(void *data, nsapi_size_t size)
{
_lock.lock();
nsapi_size_or_error_t ret;
// If this assert is hit then there are two threads
// performing a recv at the same time which is undefined
// behavior
MBED_ASSERT(_readers == 0);
_readers++;
while (true) {
if (!_socket) {
ret = NSAPI_ERROR_NO_SOCKET;
break;
}
_pending = 0;
ret = _stack->socket_recv(_socket, data, size);
if ((_timeout == 0) || (ret != NSAPI_ERROR_WOULD_BLOCK)) {
break;
} else {
uint32_t flag;
// Release lock before blocking so other threads
// accessing this object aren't blocked
_lock.unlock();
flag = _event_flag.wait_any(READ_FLAG, _timeout);
_lock.lock();
if (flag & osFlagsError) {
// Timeout break
ret = NSAPI_ERROR_WOULD_BLOCK;
break;
}
}
}
_readers--;
if (!_socket) {
_event_flag.set(FINISHED_FLAG);
}
_lock.unlock();
return ret;
}
nsapi_size_or_error_t TCPSocket::recvfrom(SocketAddress *address, void *data, nsapi_size_t size)
{
if (address) {
*address = _remote_peer;
}
return recv(data, size);
}
nsapi_error_t TCPSocket::listen(int backlog)
{
_lock.lock();
nsapi_error_t ret;
if (!_socket) {
ret = NSAPI_ERROR_NO_SOCKET;
} else {
ret = _stack->socket_listen(_socket, backlog);
}
_lock.unlock();
return ret;
}
TCPSocket *TCPSocket::accept(nsapi_error_t *error)
{
_lock.lock();
TCPSocket *connection = NULL;
nsapi_error_t ret;
_readers++;
while (true) {
if (!_socket) {
ret = NSAPI_ERROR_NO_SOCKET;
break;
}
_pending = 0;
void *socket;
SocketAddress address;
ret = _stack->socket_accept(_socket, &socket, &address);
if (0 == ret) {
TCPSocket *connection = new TCPSocket();
connection->_lock.lock();
connection->_factory_allocated = true; // Destroy automatically on close()
connection->_remote_peer = address;
connection->_stack = _stack;
connection->_socket = socket;
connection->_event = mbed::Callback<void()>(connection, &TCPSocket::event);
_stack->socket_attach(socket, &mbed::Callback<void()>::thunk, &connection->_event);
connection->_lock.unlock();
break;
} else if ((_timeout == 0) || (ret != NSAPI_ERROR_WOULD_BLOCK)) {
break;
} else {
uint32_t flag;
// Release lock before blocking so other threads
// accessing this object aren't blocked
_lock.unlock();
flag = _event_flag.wait_any(READ_FLAG, _timeout);
_lock.lock();
if (flag & osFlagsError) {
// Timeout break
ret = NSAPI_ERROR_WOULD_BLOCK;
break;
}
}
}
_readers--;
if (!_socket) {
_event_flag.set(FINISHED_FLAG);
}
_lock.unlock();
if (error) {
*error = ret;
}
return connection;
}