ardupilot/libraries/AP_HAL/utility/Socket.cpp

228 lines
4.9 KiB
C++
Raw Normal View History

2015-05-05 08:27:33 -03:00
/*
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/*
simple socket handling class for systems with BSD socket API
*/
#include <AP_HAL/AP_HAL.h>
2015-05-05 08:27:33 -03:00
#if HAL_OS_SOCKETS
#include "Socket.h"
/*
constructor
*/
SocketAPM::SocketAPM(bool _datagram) :
SocketAPM(_datagram,
socket(AF_INET, _datagram?SOCK_DGRAM:SOCK_STREAM, 0))
{}
SocketAPM::SocketAPM(bool _datagram, int _fd) :
datagram(_datagram),
fd(_fd)
2015-05-05 08:27:33 -03:00
{
fcntl(fd, F_SETFD, FD_CLOEXEC);
if (!datagram) {
int one = 1;
setsockopt(fd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
}
2015-05-05 08:27:33 -03:00
}
2015-06-11 18:48:24 -03:00
SocketAPM::~SocketAPM()
{
2015-07-28 19:39:16 -03:00
if (fd != -1) {
::close(fd);
fd = -1;
2015-06-11 18:48:24 -03:00
}
}
2015-05-22 02:53:33 -03:00
void SocketAPM::make_sockaddr(const char *address, uint16_t port, struct sockaddr_in &sockaddr)
2015-05-05 08:27:33 -03:00
{
memset(&sockaddr, 0, sizeof(sockaddr));
#ifdef HAVE_SOCK_SIN_LEN
sockaddr.sin_len = sizeof(sockaddr);
#endif
sockaddr.sin_port = htons(port);
sockaddr.sin_family = AF_INET;
sockaddr.sin_addr.s_addr = inet_addr(address);
2015-05-22 02:53:33 -03:00
}
/*
connect the socket
*/
bool SocketAPM::connect(const char *address, uint16_t port)
{
struct sockaddr_in sockaddr;
make_sockaddr(address, port, sockaddr);
2015-05-05 08:27:33 -03:00
if (::connect(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) != 0) {
return false;
}
return true;
}
/*
bind the socket
*/
bool SocketAPM::bind(const char *address, uint16_t port)
{
struct sockaddr_in sockaddr;
2015-05-22 02:53:33 -03:00
make_sockaddr(address, port, sockaddr);
2015-05-05 08:27:33 -03:00
if (::bind(fd, (struct sockaddr *)&sockaddr, sizeof(sockaddr)) != 0) {
return false;
}
return true;
}
/*
set SO_REUSEADDR
*/
void SocketAPM::reuseaddress(void)
{
int one = 1;
setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &one, sizeof(one));
}
/*
set blocking state
*/
void SocketAPM::set_blocking(bool blocking)
{
if (blocking) {
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) & ~O_NONBLOCK);
} else {
fcntl(fd, F_SETFL, fcntl(fd, F_GETFL, 0) | O_NONBLOCK);
}
}
/*
send some data
*/
ssize_t SocketAPM::send(const void *buf, size_t size)
2015-05-05 08:27:33 -03:00
{
return ::send(fd, buf, size, 0);
}
2015-05-22 02:53:33 -03:00
/*
send some data
*/
ssize_t SocketAPM::sendto(const void *buf, size_t size, const char *address, uint16_t port)
2015-05-22 02:53:33 -03:00
{
struct sockaddr_in sockaddr;
make_sockaddr(address, port, sockaddr);
return ::sendto(fd, buf, size, 0, (struct sockaddr *)&sockaddr, sizeof(sockaddr));
}
2015-05-05 08:27:33 -03:00
/*
receive some data
*/
ssize_t SocketAPM::recv(void *buf, size_t size, uint32_t timeout_ms)
{
if (!pollin(timeout_ms)) {
return -1;
}
socklen_t len = sizeof(in_addr);
return ::recvfrom(fd, buf, size, MSG_DONTWAIT, (sockaddr *)&in_addr, &len);
}
/*
return the IP address and port of the last received packet
*/
void SocketAPM::last_recv_address(const char *&ip_addr, uint16_t &port)
{
ip_addr = inet_ntoa(in_addr.sin_addr);
port = ntohs(in_addr.sin_port);
}
void SocketAPM::set_broadcast(void)
{
int one = 1;
setsockopt(fd,SOL_SOCKET,SO_BROADCAST,(char *)&one,sizeof(one));
}
/*
return true if there is pending data for input
*/
bool SocketAPM::pollin(uint32_t timeout_ms)
2015-05-05 08:27:33 -03:00
{
fd_set fds;
struct timeval tv;
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec = timeout_ms / 1000;
tv.tv_usec = (timeout_ms % 1000) * 1000UL;
if (select(fd+1, &fds, NULL, NULL, &tv) != 1) {
return false;
2015-05-05 08:27:33 -03:00
}
return true;
2015-05-05 08:27:33 -03:00
}
/*
return true if there is room for output data
*/
bool SocketAPM::pollout(uint32_t timeout_ms)
{
fd_set fds;
struct timeval tv;
FD_ZERO(&fds);
FD_SET(fd, &fds);
tv.tv_sec = timeout_ms / 1000;
tv.tv_usec = (timeout_ms % 1000) * 1000UL;
if (select(fd+1, NULL, &fds, NULL, &tv) != 1) {
return false;
}
return true;
}
/*
start listening for new tcp connections
*/
bool SocketAPM::listen(uint16_t backlog)
{
return ::listen(fd, (int)backlog) == 0;
}
/*
accept a new connection. Only valid for TCP connections after
listen has been used. A new socket is returned
*/
SocketAPM *SocketAPM::accept(uint32_t timeout_ms)
{
if (!pollin(timeout_ms)) {
return NULL;
}
int newfd = ::accept(fd, NULL, NULL);
if (newfd == -1) {
return NULL;
}
// turn off nagle for lower latency
int one = 1;
setsockopt(newfd, IPPROTO_TCP, TCP_NODELAY, &one, sizeof(one));
return new SocketAPM(false, newfd);
}
2015-05-05 08:27:33 -03:00
#endif // HAL_OS_SOCKETS