serval-dna/mdp_client.c

443 lines
14 KiB
C
Raw Normal View History

/*
Copyright (C) 2010-2012 Paul Gardner-Stephen
Copyright (C) 2010-2013 Serval Project Inc.
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 2
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, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#include <inttypes.h> // for PRIx64 on Android
#include <sys/stat.h>
#include "conf.h"
#include "log.h"
#include "debug.h"
#include "str.h"
#include "strbuf.h"
#include "strbuf_helpers.h"
#include "overlay_buffer.h"
#include "overlay_address.h"
#include "overlay_interface.h"
#include "overlay_packet.h"
#include "mdp_client.h"
#include "socket.h"
int _mdp_socket(struct __sourceloc UNUSED(__whence))
{
// for now use the same process for creating sockets
// TODO make overlay_mdp_client_socket() take __whence arg
return overlay_mdp_client_socket();
}
int _mdp_close(struct __sourceloc __whence, int socket)
{
// tell the daemon to drop all bindings
struct mdp_header header={
.flags = MDP_FLAG_CLOSE,
.local.port = 0,
};
mdp_send(socket, &header, NULL, 0);
// remove socket
socket_unlink_close(socket);
return 0;
}
int _mdp_send(struct __sourceloc __whence, int socket, const struct mdp_header *header, const uint8_t *payload, size_t len)
{
struct socket_address addr;
if (make_local_sockaddr(&addr, "mdp.2.socket") == -1)
return -1;
struct fragmented_data data={
.fragment_count = len ? 2 : 1,
.iov={
{
.iov_base = (void*)header,
.iov_len = sizeof(struct mdp_header)
},
{
.iov_base = (void*)payload,
.iov_len = len
}
}
};
2014-04-16 09:38:42 +00:00
ssize_t sent = send_message(socket, &addr, &data);
if (sent == -1)
return -1;
if ((size_t)sent != sizeof *header + len) {
errno = EMSGSIZE;
return WHYF("send_message(%d,%s,%s) returned %zd, expecting %zd -- setting errno = EMSGSIZE",
2014-04-16 09:38:42 +00:00
socket,
alloca_socket_address(&addr),
alloca_fragmented_data(&data),
(size_t)sent,
sizeof *header + len
);
}
2014-04-16 09:38:42 +00:00
return 0;
}
/* This function is designed to be used a bit like a system or library call, because it always sets
* errno before returning -1. Some errno values arise from system calls, and some are synthetic,
* eg, to report buffer overflow or an MDP protocol error.
*/
ssize_t _mdp_recv(struct __sourceloc __whence, int socket, struct mdp_header *header, uint8_t *payload, size_t max_len)
{
/* Construct name of socket to receive from. */
struct socket_address mdp_addr;
if (make_local_sockaddr(&mdp_addr, "mdp.2.socket") == -1) {
errno = EOVERFLOW;
WHY_perror("Failed to build socket address, setting errno=EOVERFLOW");
return -1;
}
struct socket_address addr;
2014-06-05 05:26:19 +00:00
bzero(&addr, sizeof addr);
struct iovec iov[]={
{
.iov_base = (void *)header,
.iov_len = sizeof(struct mdp_header)
},
{
.iov_base = (void *)payload,
.iov_len = max_len
}
};
struct msghdr hdr={
.msg_name=&addr.addr,
.msg_namelen=sizeof(addr.store),
.msg_iov=iov,
.msg_iovlen= max_len ? 2 : 1,
};
ssize_t len = recvmsg(socket, &hdr, 0);
if (len == -1) {
// Do not log errors that are part of normal operation.
if ( errno != EAGAIN
#ifdef EWOULDBLOCK
&& errno != EWOULDBLOCK
#endif
&& errno != EINTR
)
WHYF_perror("recvmsg(%d,%p,0)", socket, &hdr);
return -1;
}
if ((size_t)len < sizeof(struct mdp_header)) {
errno = EBADMSG;
WHYF_perror("received message too short (%zu), setting errno=EBADMSG", (size_t)len);
return -1;
}
addr.addrlen=hdr.msg_namelen;
// double check that the incoming address matches the servald daemon
if (cmp_sockaddr(&addr, &mdp_addr) != 0
&& ( addr.local.sun_family != AF_UNIX
|| real_sockaddr(&addr, &addr) <= 0
|| cmp_sockaddr(&addr, &mdp_addr) != 0
)
) {
errno = EBADMSG;
WARNF_perror("dropped message from %s (expecting %s), setting errno=EBADMSG",
alloca_socket_address(&addr),
alloca_socket_address(&mdp_addr));
return -1;
}
return len - sizeof(struct mdp_header);
}
int _mdp_bind(struct __sourceloc __whence, int socket, struct mdp_sockaddr *local_addr)
{
struct mdp_header mdp_header;
bzero(&mdp_header, sizeof(mdp_header));
mdp_header.local = *local_addr;
mdp_header.remote.port = MDP_LISTEN;
mdp_header.remote.sid = SID_ANY;
mdp_header.flags = MDP_FLAG_BIND;
if (_mdp_send(__whence, socket, &mdp_header, NULL, 0)==-1)
return -1;
if (_mdp_recv(__whence, socket, &mdp_header, NULL, 0)==-1)
return -1;
if (mdp_header.flags & MDP_FLAG_ERROR){
errno = EBADMSG;
return -1;
}
*local_addr = mdp_header.local;
return 0;
}
int _mdp_poll(struct __sourceloc UNUSED(__whence), int socket, time_ms_t timeout_ms)
{
// TODO make overlay_mdp_client_poll() take __whence arg
return overlay_mdp_client_poll(socket, timeout_ms);
}
// returns -1 on error, -2 on timeout, packet length on success.
ssize_t mdp_poll_recv(int mdp_sock, time_ms_t deadline, struct mdp_header *rev_header, unsigned char *payload, size_t buffer_size)
{
time_ms_t now = gettime_ms();
if (now > deadline)
return -2;
int p = mdp_poll(mdp_sock, deadline - now);
if (p == -1)
return WHY_perror("mdp_poll");
if (p == 0)
return -2;
ssize_t len = mdp_recv(mdp_sock, rev_header, payload, buffer_size);
if (len == -1)
return -1;
if (rev_header->flags & MDP_FLAG_ERROR)
return WHY("Operation failed, check the daemon log for more information");
return len;
}
int overlay_mdp_send(int mdp_sockfd, overlay_mdp_frame *mdp, int flags, int timeout_ms)
{
if (mdp_sockfd == -1)
return WHY("Invalid socket descriptor");
// Minimise frame length to save work and prevent accidental disclosure of memory contents.
ssize_t len = overlay_mdp_relevant_bytes(mdp);
if (len == -1)
return WHY("MDP frame invalid (could not compute length)");
/* Construct name of socket to send to. */
struct socket_address addr;
if (make_local_sockaddr(&addr, "mdp.socket") == -1)
return WHY("Failed to make socket address");
// Send to that socket
set_nonblock(mdp_sockfd);
ssize_t result = sendto(mdp_sockfd, mdp, (size_t)len, 0, &addr.addr, addr.addrlen);
set_block(mdp_sockfd);
if ((size_t)result != (size_t)len) {
if (result == -1)
WHYF_perror("sendto(fd=%d,len=%zu,addr=%s)", mdp_sockfd, (size_t)len, alloca_socket_address(&addr));
else
WHYF("sendto() sent %zu bytes of MDP reply (%zu) to %s", (size_t)result, (size_t)len, alloca_socket_address(&addr));
mdp->packetTypeAndFlags=MDP_ERROR;
mdp->error.error=1;
snprintf(mdp->error.message,128,"Error sending frame to MDP server.");
return -1;
} else {
if (!(flags&MDP_AWAITREPLY)) {
return 0;
}
}
2013-10-09 08:52:51 +00:00
mdp_port_t port=0;
if ((mdp->packetTypeAndFlags&MDP_TYPE_MASK) == MDP_TX)
2013-02-18 04:01:01 +00:00
port = mdp->out.src.port;
time_ms_t started = gettime_ms();
while(timeout_ms>=0 && overlay_mdp_client_poll(mdp_sockfd, timeout_ms)>0){
int ttl=-1;
if (!overlay_mdp_recv(mdp_sockfd, mdp, port, &ttl)) {
/* If all is well, examine result and return error code provided */
if ((mdp->packetTypeAndFlags&MDP_TYPE_MASK)==MDP_ERROR)
return mdp->error.error;
else
/* Something other than an error has been returned */
return 0;
}
// work out how much longer we can wait for a valid response
time_ms_t now = gettime_ms();
timeout_ms -= (now - started);
}
/* Timeout */
mdp->packetTypeAndFlags=MDP_ERROR;
mdp->error.error=1;
snprintf(mdp->error.message,128,"Timeout waiting for reply to MDP packet (packet was successfully sent).");
return -1; /* WHY("Timeout waiting for server response"); */
}
/** Create a new MDP socket and return its descriptor (-1 on error). */
int overlay_mdp_client_socket(void)
{
/* Create local per-client socket to MDP server (connection is always local) */
int mdp_sockfd;
struct socket_address addr;
uint32_t random_value;
if (urandombytes((unsigned char *)&random_value, sizeof random_value) == -1)
return WHY("urandombytes() failed");
if (make_local_sockaddr(&addr, "mdp.client.%u.%08lx.socket", getpid(), (unsigned long)random_value) == -1)
return -1;
if ((mdp_sockfd = esocket(AF_UNIX, SOCK_DGRAM, 0)) == -1)
return -1;
if (socket_bind(mdp_sockfd, &addr) == -1) {
close(mdp_sockfd);
return -1;
}
socket_set_rcvbufsize(mdp_sockfd, 128 * 1024);
return mdp_sockfd;
}
int overlay_mdp_client_close(int mdp_sockfd)
{
/* Tell MDP server to release all our bindings */
overlay_mdp_frame mdp;
mdp.packetTypeAndFlags = MDP_GOODBYE;
overlay_mdp_send(mdp_sockfd, &mdp, 0, 0);
socket_unlink_close(mdp_sockfd);
2013-01-15 05:45:36 +00:00
return 0;
}
int overlay_mdp_client_poll(int mdp_sockfd, time_ms_t timeout_ms)
{
fd_set r;
FD_ZERO(&r);
FD_SET(mdp_sockfd, &r);
if (timeout_ms<0) timeout_ms=0;
struct pollfd fds[]={
{
.fd = mdp_sockfd,
.events = POLLIN|POLLERR,
}
};
return poll(fds, 1, timeout_ms);
}
2013-10-09 08:52:51 +00:00
int overlay_mdp_recv(int mdp_sockfd, overlay_mdp_frame *mdp, mdp_port_t port, int *ttl)
{
/* Construct name of socket to receive from. */
struct socket_address mdp_addr;
if (make_local_sockaddr(&mdp_addr, "mdp.socket") == -1)
return -1;
/* Check if reply available */
struct socket_address recvaddr;
recvaddr.addrlen = sizeof recvaddr.store;
ssize_t len;
mdp->packetTypeAndFlags = 0;
set_nonblock(mdp_sockfd);
len = recv_message(mdp_sockfd, &recvaddr, ttl, (unsigned char *)mdp, sizeof(overlay_mdp_frame));
set_block(mdp_sockfd);
if (len <= 0)
return -1; // no packet received
// If the received address overflowed the buffer, then it cannot have come from the server, whose
// address must always fit within a struct sockaddr_un.
if (recvaddr.addrlen > sizeof recvaddr.store)
return WHYF("reply did not come from server %s: address overrun", alloca_socket_address(&mdp_addr));
// Compare the address of the sender with the address of our server, to ensure they are the same.
// If the comparison fails, then try using realpath(3) on the sender address and compare again.
if ( cmp_sockaddr(&recvaddr, &mdp_addr) != 0
&& ( recvaddr.local.sun_family != AF_UNIX
|| real_sockaddr(&recvaddr, &recvaddr) <= 0
|| cmp_sockaddr(&recvaddr, &mdp_addr) != 0
)
)
return WHYF("reply did not come from server %s: %s", alloca_socket_address(&mdp_addr), alloca_socket_address(&recvaddr));
// silently drop incoming packets for the wrong port number
if (port>0 && port != mdp->out.dst.port){
WARNF("Ignoring packet for port %"PRImdp_port_t,mdp->out.dst.port);
return -1;
}
ssize_t expected_len = overlay_mdp_relevant_bytes(mdp);
if (expected_len < 0)
return WHY("unsupported MDP packet type");
if ((size_t)len < (size_t)expected_len)
return WHYF("Expected packet length of %zu, received only %zd bytes", (size_t) expected_len, (size_t) len);
/* Valid packet received */
return 0;
}
// send a request to servald deamon to add a port binding
2013-10-09 08:52:51 +00:00
int overlay_mdp_bind(int mdp_sockfd, const sid_t *localaddr, mdp_port_t port)
{
overlay_mdp_frame mdp;
mdp.packetTypeAndFlags=MDP_BIND|MDP_FORCE;
mdp.bind.sid = *localaddr;
mdp.bind.port=port;
int result=overlay_mdp_send(mdp_sockfd, &mdp,MDP_AWAITREPLY,5000);
if (result) {
if (mdp.packetTypeAndFlags==MDP_ERROR)
2013-10-09 08:52:51 +00:00
WHYF("Could not bind to MDP port %"PRImdp_port_t": error=%d, message='%s'",
port,mdp.error.error,mdp.error.message);
else
2013-10-09 08:52:51 +00:00
WHYF("Could not bind to MDP port %"PRImdp_port_t" (no reason given)",port);
return -1;
}
return 0;
}
int overlay_mdp_getmyaddr(int mdp_sockfd, unsigned index, sid_t *sidp)
{
overlay_mdp_frame a;
memset(&a, 0, sizeof(a));
a.packetTypeAndFlags=MDP_GETADDRS;
a.addrlist.mode = MDP_ADDRLIST_MODE_SELF;
a.addrlist.first_sid=index;
a.addrlist.last_sid=OVERLAY_MDP_ADDRLIST_MAX_SID_COUNT;
a.addrlist.frame_sid_count=MDP_MAX_SID_REQUEST;
int result=overlay_mdp_send(mdp_sockfd,&a,MDP_AWAITREPLY,5000);
if (result) {
if (a.packetTypeAndFlags == MDP_ERROR)
WARNF("MDP Server error #%d: '%s'", a.error.error, a.error.message);
return WHY("Failed to get local address list");
}
if ((a.packetTypeAndFlags&MDP_TYPE_MASK)!=MDP_ADDRLIST)
return WHY("MDP Server returned something other than an address list");
if (0) WARNF("local addr 0 = %s",alloca_tohex_sid_t(a.addrlist.sids[0]));
*sidp = a.addrlist.sids[0];
return 0;
}
ssize_t overlay_mdp_relevant_bytes(overlay_mdp_frame *mdp)
{
size_t len;
switch(mdp->packetTypeAndFlags&MDP_TYPE_MASK)
{
2012-11-26 04:10:22 +00:00
case MDP_ROUTING_TABLE:
case MDP_GOODBYE:
/* no arguments for saying goodbye */
len=&mdp->raw[0]-(char *)mdp;
break;
case MDP_ADDRLIST:
len = mdp->addrlist.sids[mdp->addrlist.frame_sid_count].binary - (unsigned char *)mdp;
break;
case MDP_GETADDRS:
len = mdp->addrlist.sids[0].binary - (unsigned char *)mdp;
break;
case MDP_TX:
len=(&mdp->out.payload[0]-(unsigned char *)mdp) + mdp->out.payload_length;
break;
case MDP_BIND:
// make sure that the compiler has actually given these two structures the same address
// I've seen gcc 4.8.1 on x64 fail to give elements the same address once
assert((void *)mdp->raw == (void *)&mdp->bind);
len=(&mdp->raw[0] - (char *)mdp) + sizeof(struct mdp_sockaddr);
break;
case MDP_SCAN:
len=(&mdp->raw[0] - (char *)mdp) + sizeof(struct overlay_mdp_scan);
break;
case MDP_ERROR:
/* This formulation is used so that we don't copy any bytes after the
end of the string, to avoid information leaks */
len=(&mdp->error.message[0]-(char *)mdp) + strlen(mdp->error.message)+1;
break;
default:
return WHY("Illegal MDP frame type.");
}
return len;
}