2015-09-02 22:17:38 +00:00
|
|
|
/*
|
|
|
|
* ZeroTier One - Network Virtualization Everywhere
|
|
|
|
* Copyright (C) 2011-2015 ZeroTier, 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 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/>.
|
|
|
|
*
|
|
|
|
* --
|
|
|
|
*
|
|
|
|
* ZeroTier may be used and distributed under the terms of the GPLv3, which
|
|
|
|
* are available at: http://www.gnu.org/licenses/gpl-3.0.html
|
|
|
|
*
|
|
|
|
* If you would like to embed ZeroTier into a commercial application or
|
|
|
|
* redistribute it in a modified binary form, please contact ZeroTier Networks
|
|
|
|
* LLC. Start here: http://www.zerotier.com/
|
|
|
|
*/
|
|
|
|
|
2015-09-03 23:05:18 +00:00
|
|
|
#include <algorithm>
|
|
|
|
#include <utility>
|
2015-09-11 00:02:13 +00:00
|
|
|
#include <dlfcn.h>
|
2015-11-23 21:02:50 +00:00
|
|
|
#include <sys/poll.h>
|
2015-09-11 00:02:13 +00:00
|
|
|
|
2015-09-02 22:17:38 +00:00
|
|
|
#include "NetconEthernetTap.hpp"
|
|
|
|
|
2015-09-02 22:51:28 +00:00
|
|
|
#include "../node/Utils.hpp"
|
2015-09-02 22:17:38 +00:00
|
|
|
#include "../osdep/OSUtils.hpp"
|
|
|
|
#include "../osdep/Phy.hpp"
|
|
|
|
|
2015-11-23 21:02:50 +00:00
|
|
|
#include "Intercept.h"
|
|
|
|
#include "LWIPStack.hpp"
|
|
|
|
|
2015-09-10 17:56:01 +00:00
|
|
|
#include "lwip/tcp_impl.h"
|
|
|
|
#include "netif/etharp.h"
|
2015-11-23 21:02:50 +00:00
|
|
|
#include "lwip/api.h"
|
2015-09-10 17:56:01 +00:00
|
|
|
#include "lwip/ip.h"
|
|
|
|
#include "lwip/ip_addr.h"
|
|
|
|
#include "lwip/ip_frag.h"
|
2015-09-15 18:15:59 +00:00
|
|
|
#include "lwip/tcp.h"
|
2015-09-10 17:56:01 +00:00
|
|
|
|
2015-11-23 21:25:46 +00:00
|
|
|
#include "common.inc.c"
|
2015-09-10 17:56:01 +00:00
|
|
|
|
2015-11-17 03:53:59 +00:00
|
|
|
#define APPLICATION_POLL_FREQ 20
|
2015-11-04 22:45:26 +00:00
|
|
|
#define ZT_LWIP_TCP_TIMER_INTERVAL 5
|
2015-11-17 03:53:59 +00:00
|
|
|
#define STATUS_TMR_INTERVAL 3000 // How often we check connection statuses
|
2015-10-14 23:55:21 +00:00
|
|
|
|
2015-09-02 22:17:38 +00:00
|
|
|
namespace ZeroTier {
|
|
|
|
|
2015-11-23 21:18:46 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
|
|
|
/*
|
|
|
|
static void clearscreen(){
|
|
|
|
fprintf(stderr, "\033[2J");
|
|
|
|
}
|
|
|
|
static void gotoxy(int x,int y) {
|
|
|
|
fprintf(stderr, "%c[%d;%df",0x1B,y,x);
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
|
|
|
// Gets the process/path name associated with a pid
|
|
|
|
static void get_path_from_pid(char* dest, int pid)
|
|
|
|
{
|
|
|
|
char ppath[80];
|
|
|
|
sprintf(ppath, "/proc/%d/exe", pid);
|
|
|
|
if (readlink (ppath, dest, 80) != -1){
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Gets the process/path name associated with a fd
|
|
|
|
/*
|
|
|
|
static void get_path_from_fd(char* dest, int pid, int fd)
|
|
|
|
{
|
|
|
|
char ppfd[80];
|
|
|
|
sprintf(ppfd, "/proc/%d/fd/%d", pid, fd);
|
|
|
|
if (readlink (ppfd, dest, 80) != -1){
|
|
|
|
}
|
|
|
|
}
|
|
|
|
*/
|
|
|
|
|
2015-11-23 20:43:42 +00:00
|
|
|
static err_t tapif_init(struct netif *netif)
|
|
|
|
{
|
|
|
|
// Actual init functionality is in addIp() of tap
|
|
|
|
return ERR_OK;
|
|
|
|
}
|
|
|
|
|
|
|
|
static err_t low_level_output(struct netif *netif, struct pbuf *p)
|
|
|
|
{
|
|
|
|
struct pbuf *q;
|
|
|
|
char buf[ZT_MAX_MTU+32];
|
|
|
|
char *bufptr;
|
|
|
|
int tot_len = 0;
|
|
|
|
|
|
|
|
ZeroTier::NetconEthernetTap *tap = (ZeroTier::NetconEthernetTap*)netif->state;
|
|
|
|
|
|
|
|
/* initiate transfer(); */
|
|
|
|
bufptr = buf;
|
|
|
|
|
|
|
|
for(q = p; q != NULL; q = q->next) {
|
|
|
|
/* Send the data from the pbuf to the interface, one pbuf at a
|
|
|
|
time. The size of the data in each pbuf is kept in the ->len
|
|
|
|
variable. */
|
|
|
|
/* send data from(q->payload, q->len); */
|
|
|
|
memcpy(bufptr, q->payload, q->len);
|
|
|
|
bufptr += q->len;
|
|
|
|
tot_len += q->len;
|
|
|
|
}
|
|
|
|
|
|
|
|
// [Send packet to network]
|
|
|
|
// Split ethernet header and feed into handler
|
|
|
|
struct eth_hdr *ethhdr;
|
|
|
|
ethhdr = (struct eth_hdr *)buf;
|
|
|
|
|
|
|
|
ZeroTier::MAC src_mac;
|
|
|
|
ZeroTier::MAC dest_mac;
|
|
|
|
|
|
|
|
src_mac.setTo(ethhdr->src.addr, 6);
|
|
|
|
dest_mac.setTo(ethhdr->dest.addr, 6);
|
|
|
|
|
|
|
|
tap->_handler(tap->_arg,tap->_nwid,src_mac,dest_mac,
|
|
|
|
Utils::ntoh((uint16_t)ethhdr->type),0,buf + sizeof(struct eth_hdr),tot_len - sizeof(struct eth_hdr));
|
|
|
|
return ERR_OK;
|
|
|
|
}
|
|
|
|
|
2015-11-23 21:02:50 +00:00
|
|
|
/*
|
|
|
|
* TCP connection administered by service
|
|
|
|
*/
|
|
|
|
class TcpConnection
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
int perceived_fd;
|
|
|
|
int their_fd;
|
|
|
|
bool pending;
|
|
|
|
bool listening;
|
|
|
|
int pid;
|
|
|
|
|
|
|
|
unsigned long written;
|
|
|
|
unsigned long acked;
|
|
|
|
|
|
|
|
PhySocket *rpcSock;
|
|
|
|
PhySocket *dataSock;
|
|
|
|
struct tcp_pcb *pcb;
|
|
|
|
|
2015-12-09 20:20:38 +00:00
|
|
|
struct sockaddr_in *addr;
|
|
|
|
|
2015-11-23 21:02:50 +00:00
|
|
|
unsigned char buf[DEFAULT_READ_BUFFER_SIZE];
|
|
|
|
int idx;
|
|
|
|
};
|
|
|
|
|
|
|
|
/*
|
|
|
|
* A helper class for passing a reference to _phy to LWIP callbacks as a "state"
|
|
|
|
*/
|
|
|
|
class Larg
|
|
|
|
{
|
|
|
|
public:
|
|
|
|
NetconEthernetTap *tap;
|
|
|
|
TcpConnection *conn;
|
|
|
|
Larg(NetconEthernetTap *_tap, TcpConnection *conn) : tap(_tap), conn(conn) {}
|
|
|
|
};
|
2015-11-23 20:43:42 +00:00
|
|
|
|
2015-11-23 21:18:46 +00:00
|
|
|
// ---------------------------------------------------------------------------
|
|
|
|
|
2015-09-02 22:17:38 +00:00
|
|
|
NetconEthernetTap::NetconEthernetTap(
|
|
|
|
const char *homePath,
|
|
|
|
const MAC &mac,
|
|
|
|
unsigned int mtu,
|
|
|
|
unsigned int metric,
|
|
|
|
uint64_t nwid,
|
|
|
|
const char *friendlyName,
|
|
|
|
void (*handler)(void *,uint64_t,const MAC &,const MAC &,unsigned int,unsigned int,const void *,unsigned int),
|
|
|
|
void *arg) :
|
2015-11-23 20:43:42 +00:00
|
|
|
_nwid(nwid),
|
2015-09-02 22:17:38 +00:00
|
|
|
_handler(handler),
|
|
|
|
_arg(arg),
|
2015-11-23 20:43:42 +00:00
|
|
|
_phy(this,false,true),
|
|
|
|
_unixListenSocket((PhySocket *)0),
|
2015-09-11 19:12:45 +00:00
|
|
|
_mac(mac),
|
2015-09-02 22:17:38 +00:00
|
|
|
_homePath(homePath),
|
|
|
|
_mtu(mtu),
|
2015-09-02 22:51:28 +00:00
|
|
|
_enabled(true),
|
|
|
|
_run(true)
|
2015-09-02 22:17:38 +00:00
|
|
|
{
|
2015-11-23 21:18:46 +00:00
|
|
|
char sockPath[4096],lwipPath[4096];
|
2015-11-20 09:08:38 +00:00
|
|
|
rpc_counter = -1;
|
2015-12-04 20:39:54 +00:00
|
|
|
Utils::snprintf(sockPath,sizeof(sockPath),"/tmp/.ztnc_%.16llx",_nwid,ZT_PATH_SEPARATOR_S,(unsigned long long)nwid);
|
2015-11-23 21:18:46 +00:00
|
|
|
_dev = sockPath; // in netcon mode, set device to be just the network ID
|
2015-09-02 22:51:28 +00:00
|
|
|
|
2015-11-23 21:18:46 +00:00
|
|
|
Utils::snprintf(lwipPath,sizeof(lwipPath),"%s%sliblwip.so",homePath,ZT_PATH_SEPARATOR_S);
|
|
|
|
lwipstack = new LWIPStack(lwipPath);
|
2015-10-31 00:00:30 +00:00
|
|
|
if(!lwipstack)
|
2015-11-23 21:18:46 +00:00
|
|
|
throw std::runtime_error("unable to dynamically load a new instance of liblwip.so (searched ZeroTier home path)");
|
2015-09-10 17:56:01 +00:00
|
|
|
lwipstack->lwip_init();
|
|
|
|
|
2015-09-03 23:05:18 +00:00
|
|
|
_unixListenSocket = _phy.unixListen(sockPath,(void *)this);
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_INFO, " NetconEthernetTap initialized!\n", _phy.getDescriptor(_unixListenSocket));
|
2015-09-02 23:15:22 +00:00
|
|
|
if (!_unixListenSocket)
|
2015-09-02 22:51:28 +00:00
|
|
|
throw std::runtime_error(std::string("unable to bind to ")+sockPath);
|
2015-09-02 22:17:38 +00:00
|
|
|
_thread = Thread::start(this);
|
|
|
|
}
|
|
|
|
|
|
|
|
NetconEthernetTap::~NetconEthernetTap()
|
|
|
|
{
|
2015-09-02 22:51:28 +00:00
|
|
|
_run = false;
|
2015-09-03 23:05:18 +00:00
|
|
|
_phy.whack();
|
|
|
|
_phy.whack();
|
2015-09-02 22:51:28 +00:00
|
|
|
Thread::join(_thread);
|
2015-09-03 23:05:18 +00:00
|
|
|
_phy.close(_unixListenSocket,false);
|
2015-09-24 18:11:16 +00:00
|
|
|
delete lwipstack;
|
2015-09-02 22:17:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void NetconEthernetTap::setEnabled(bool en)
|
|
|
|
{
|
|
|
|
_enabled = en;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool NetconEthernetTap::enabled() const
|
|
|
|
{
|
|
|
|
return _enabled;
|
|
|
|
}
|
|
|
|
|
|
|
|
bool NetconEthernetTap::addIp(const InetAddress &ip)
|
|
|
|
{
|
2015-09-03 23:05:18 +00:00
|
|
|
Mutex::Lock _l(_ips_m);
|
|
|
|
if (std::find(_ips.begin(),_ips.end(),ip) == _ips.end()) {
|
|
|
|
_ips.push_back(ip);
|
|
|
|
std::sort(_ips.begin(),_ips.end());
|
|
|
|
|
2015-09-11 19:12:45 +00:00
|
|
|
if (ip.isV4()) {
|
2015-09-22 21:43:20 +00:00
|
|
|
// Set IP
|
|
|
|
static ip_addr_t ipaddr, netmask, gw;
|
|
|
|
IP4_ADDR(&gw,192,168,0,1);
|
|
|
|
ipaddr.addr = *((u32_t *)ip.rawIpData());
|
|
|
|
netmask.addr = *((u32_t *)ip.netmask().rawIpData());
|
|
|
|
|
|
|
|
// Set up the lwip-netif for LWIP's sake
|
2015-09-24 19:56:48 +00:00
|
|
|
lwipstack->netif_add(&interface,&ipaddr, &netmask, &gw, NULL, tapif_init, lwipstack->_ethernet_input);
|
2015-09-22 21:43:20 +00:00
|
|
|
interface.state = this;
|
2015-09-24 19:56:48 +00:00
|
|
|
interface.output = lwipstack->_etharp_output;
|
2015-09-22 21:43:20 +00:00
|
|
|
_mac.copyTo(interface.hwaddr, 6);
|
|
|
|
interface.mtu = _mtu;
|
|
|
|
interface.name[0] = 't';
|
|
|
|
interface.name[1] = 'p';
|
|
|
|
interface.linkoutput = low_level_output;
|
|
|
|
interface.hwaddr_len = 6;
|
|
|
|
interface.flags = NETIF_FLAG_BROADCAST | NETIF_FLAG_ETHARP | NETIF_FLAG_IGMP;
|
|
|
|
lwipstack->netif_set_default(&interface);
|
|
|
|
lwipstack->netif_set_up(&interface);
|
2015-09-11 19:12:45 +00:00
|
|
|
}
|
2015-09-03 23:05:18 +00:00
|
|
|
}
|
2015-09-15 23:06:16 +00:00
|
|
|
return true;
|
2015-09-02 22:17:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
bool NetconEthernetTap::removeIp(const InetAddress &ip)
|
|
|
|
{
|
2015-09-03 23:05:18 +00:00
|
|
|
Mutex::Lock _l(_ips_m);
|
2015-09-03 23:44:04 +00:00
|
|
|
std::vector<InetAddress>::iterator i(std::find(_ips.begin(),_ips.end(),ip));
|
2015-09-03 23:05:18 +00:00
|
|
|
if (i == _ips.end())
|
|
|
|
return false;
|
|
|
|
_ips.erase(i);
|
2015-09-11 19:12:45 +00:00
|
|
|
if (ip.isV4()) {
|
2015-09-22 21:43:20 +00:00
|
|
|
// TODO: dealloc from LWIP
|
2015-09-11 19:12:45 +00:00
|
|
|
}
|
2015-09-03 23:05:18 +00:00
|
|
|
return true;
|
2015-09-02 22:17:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
std::vector<InetAddress> NetconEthernetTap::ips() const
|
|
|
|
{
|
2015-09-03 23:05:18 +00:00
|
|
|
Mutex::Lock _l(_ips_m);
|
|
|
|
return _ips;
|
2015-09-02 22:17:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void NetconEthernetTap::put(const MAC &from,const MAC &to,unsigned int etherType,const void *data,unsigned int len)
|
|
|
|
{
|
2015-09-22 21:43:20 +00:00
|
|
|
struct pbuf *p,*q;
|
2015-09-02 22:51:28 +00:00
|
|
|
if (!_enabled)
|
|
|
|
return;
|
2015-09-11 19:12:45 +00:00
|
|
|
|
2015-09-22 21:43:20 +00:00
|
|
|
struct eth_hdr ethhdr;
|
|
|
|
from.copyTo(ethhdr.src.addr, 6);
|
|
|
|
to.copyTo(ethhdr.dest.addr, 6);
|
|
|
|
ethhdr.type = Utils::hton((uint16_t)etherType);
|
2015-09-15 22:47:40 +00:00
|
|
|
|
|
|
|
// We allocate a pbuf chain of pbufs from the pool.
|
|
|
|
p = lwipstack->pbuf_alloc(PBUF_RAW, len+sizeof(struct eth_hdr), PBUF_POOL);
|
|
|
|
|
2015-09-22 21:43:20 +00:00
|
|
|
if (p != NULL) {
|
|
|
|
const char *dataptr = reinterpret_cast<const char *>(data);
|
|
|
|
|
|
|
|
// First pbuf gets ethernet header at start
|
|
|
|
q = p;
|
|
|
|
if (q->len < sizeof(ethhdr)) {
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_ERROR, "_put(): Dropped packet: first pbuf smaller than ethernet header\n");
|
2015-09-22 21:43:20 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
memcpy(q->payload,ðhdr,sizeof(ethhdr));
|
2015-10-28 00:12:32 +00:00
|
|
|
memcpy((char*)q->payload + sizeof(ethhdr),dataptr,q->len - sizeof(ethhdr));
|
2015-09-22 21:43:20 +00:00
|
|
|
dataptr += q->len - sizeof(ethhdr);
|
|
|
|
|
|
|
|
// Remaining pbufs (if any) get rest of data
|
|
|
|
while ((q = q->next)) {
|
|
|
|
memcpy(q->payload,dataptr,q->len);
|
|
|
|
dataptr += q->len;
|
2015-09-15 18:15:59 +00:00
|
|
|
}
|
2015-09-15 22:47:40 +00:00
|
|
|
} else {
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_ERROR, "put(): Dropped packet: no pbufs available\n");
|
2015-09-15 22:47:40 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-09-15 18:15:59 +00:00
|
|
|
|
2015-09-24 20:01:19 +00:00
|
|
|
{
|
|
|
|
Mutex::Lock _l2(lwipstack->_lock);
|
|
|
|
if(interface.input(p, &interface) != ERR_OK) {
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_ERROR, "put(): Error while RXing packet (netif->input)\n");
|
2015-09-24 20:01:19 +00:00
|
|
|
}
|
2015-09-15 22:47:40 +00:00
|
|
|
}
|
2015-09-02 22:17:38 +00:00
|
|
|
}
|
|
|
|
|
2015-11-23 21:18:46 +00:00
|
|
|
std::string NetconEthernetTap::deviceName() const
|
|
|
|
{
|
2015-09-02 22:17:38 +00:00
|
|
|
return _dev;
|
|
|
|
}
|
|
|
|
|
2015-11-12 22:49:20 +00:00
|
|
|
void NetconEthernetTap::setFriendlyName(const char *friendlyName) {
|
2015-09-02 22:17:38 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
void NetconEthernetTap::scanMulticastGroups(std::vector<MulticastGroup> &added,std::vector<MulticastGroup> &removed)
|
|
|
|
{
|
2015-09-11 19:12:45 +00:00
|
|
|
std::vector<MulticastGroup> newGroups;
|
|
|
|
Mutex::Lock _l(_multicastGroups_m);
|
|
|
|
|
2015-09-03 23:05:18 +00:00
|
|
|
// TODO: get multicast subscriptions from LWIP
|
2015-09-02 22:17:38 +00:00
|
|
|
|
2015-09-11 19:12:45 +00:00
|
|
|
std::vector<InetAddress> allIps(ips());
|
|
|
|
for(std::vector<InetAddress>::iterator ip(allIps.begin());ip!=allIps.end();++ip)
|
|
|
|
newGroups.push_back(MulticastGroup::deriveMulticastGroupForAddressResolution(*ip));
|
|
|
|
|
|
|
|
std::sort(newGroups.begin(),newGroups.end());
|
|
|
|
std::unique(newGroups.begin(),newGroups.end());
|
|
|
|
|
|
|
|
for(std::vector<MulticastGroup>::iterator m(newGroups.begin());m!=newGroups.end();++m) {
|
|
|
|
if (!std::binary_search(_multicastGroups.begin(),_multicastGroups.end(),*m))
|
|
|
|
added.push_back(*m);
|
|
|
|
}
|
|
|
|
for(std::vector<MulticastGroup>::iterator m(_multicastGroups.begin());m!=_multicastGroups.end();++m) {
|
|
|
|
if (!std::binary_search(newGroups.begin(),newGroups.end(),*m))
|
|
|
|
removed.push_back(*m);
|
|
|
|
}
|
|
|
|
_multicastGroups.swap(newGroups);
|
|
|
|
}
|
2015-09-10 21:44:01 +00:00
|
|
|
|
2015-10-30 00:57:59 +00:00
|
|
|
TcpConnection *NetconEthernetTap::getConnectionByTheirFD(PhySocket *sock, int fd)
|
2015-09-10 21:44:01 +00:00
|
|
|
{
|
2015-09-27 10:08:39 +00:00
|
|
|
for(size_t i=0; i<tcp_connections.size(); i++) {
|
2015-10-30 00:57:59 +00:00
|
|
|
if(tcp_connections[i]->perceived_fd == fd && tcp_connections[i]->rpcSock == sock)
|
2015-09-27 10:08:39 +00:00
|
|
|
return tcp_connections[i];
|
2015-09-10 21:44:01 +00:00
|
|
|
}
|
2015-09-10 22:19:43 +00:00
|
|
|
return NULL;
|
2015-09-10 21:44:01 +00:00
|
|
|
}
|
|
|
|
|
2015-10-30 00:57:59 +00:00
|
|
|
/*
|
|
|
|
* Dumps service state in 80x25 when debug mode is off
|
|
|
|
*/
|
|
|
|
void NetconEthernetTap::compact_dump()
|
2015-09-10 21:44:01 +00:00
|
|
|
{
|
2015-10-30 00:57:59 +00:00
|
|
|
/*
|
2015-10-31 00:00:30 +00:00
|
|
|
clearscreen();
|
|
|
|
gotoxy(0,0);
|
|
|
|
|
2015-10-30 00:57:59 +00:00
|
|
|
fprintf(stderr, "ZeroTier - Network Containers Service [State Dump]\n\r");
|
|
|
|
fprintf(stderr, " RPC Sockets = %d\n\r", rpc_sockets.size());
|
|
|
|
fprintf(stderr, " TCP Connections = %d\n\r", tcp_connections.size());
|
2015-10-31 00:00:30 +00:00
|
|
|
|
|
|
|
for(size_t i=0; i<rpc_sockets.size(); i++) {
|
|
|
|
int rpc_fd = _phy.getDescriptor(rpc_sockets[i]);
|
|
|
|
char buf[80];
|
|
|
|
int pid = pidmap[rpc_sockets[i]];
|
|
|
|
memset(&buf, '\0', 80);
|
|
|
|
get_path_from_pid(buf, pid);
|
|
|
|
fprintf(stderr, "\n Client(addr=0x%x, rpc=%d, pid=%d) %s\n", rpc_sockets[i], rpc_fd, pid, buf);
|
|
|
|
for(size_t j=0; j<tcp_connections.size(); j++) {
|
|
|
|
memset(&buf, '\0', 80);
|
|
|
|
get_path_from_pid(buf, tcp_connections[j]->pid);
|
|
|
|
if(tcp_connections[j]->rpcSock==rpc_sockets[i]) {
|
|
|
|
fprintf(stderr, "\t\tpath\t\t= %s\n", buf);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-11-17 03:53:59 +00:00
|
|
|
*/
|
|
|
|
for(size_t i=0; i<rpc_sockets.size(); i++) {
|
|
|
|
fprintf(stderr, "\n\n\nrpc(%d)\n", _phy.getDescriptor(rpc_sockets[i]));
|
|
|
|
for(size_t j=0; j<tcp_connections.size(); j++) {
|
|
|
|
if(_phy.getDescriptor(tcp_connections[j]->rpcSock) == _phy.getDescriptor(rpc_sockets[i]))
|
|
|
|
fprintf(stderr, "\t(%d) ----> (%d)\n\n", _phy.getDescriptor(tcp_connections[j]->dataSock), tcp_connections[j]->perceived_fd);
|
|
|
|
}
|
|
|
|
}
|
2015-10-30 00:57:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Dumps service state
|
|
|
|
*/
|
|
|
|
void NetconEthernetTap::dump()
|
|
|
|
{
|
|
|
|
fprintf(stderr, "\n\n---\n\ndie(): BEGIN SERVICE STATE DUMP\n");
|
|
|
|
fprintf(stderr, "*** IF YOU SEE THIS, EMAIL THE DUMP TEXT TO joseph.henry@zerotier.com ***\n");
|
2015-11-20 09:08:38 +00:00
|
|
|
fprintf(stderr, " tcp_conns = %lu, rpc_socks = %lu\n", tcp_connections.size(), rpc_sockets.size());
|
2015-10-30 00:57:59 +00:00
|
|
|
|
2015-11-17 03:53:59 +00:00
|
|
|
// TODO: Add logic to detect bad mapping conditions
|
2015-10-30 00:57:59 +00:00
|
|
|
for(size_t i=0; i<rpc_sockets.size(); i++) {
|
|
|
|
for(size_t j=0; j<rpc_sockets.size(); j++) {
|
|
|
|
if(j != i && rpc_sockets[i] == rpc_sockets[j]) {
|
2015-11-20 09:08:38 +00:00
|
|
|
fprintf(stderr, "Duplicate PhySockets found! (0x%p)\n", rpc_sockets[i]);
|
2015-10-30 00:57:59 +00:00
|
|
|
}
|
|
|
|
}
|
2015-09-10 22:19:43 +00:00
|
|
|
}
|
2015-10-30 00:57:59 +00:00
|
|
|
|
|
|
|
// Dump the state of the service mapping
|
|
|
|
for(size_t i=0; i<rpc_sockets.size(); i++) {
|
|
|
|
int rpc_fd = _phy.getDescriptor(rpc_sockets[i]);
|
|
|
|
char buf[80];
|
|
|
|
int pid = pidmap[rpc_sockets[i]];
|
|
|
|
get_path_from_pid(buf, pid);
|
|
|
|
|
2015-11-20 09:08:38 +00:00
|
|
|
fprintf(stderr, "\nClient(addr=0x%p, rpc=%d, pid=%d) %s\n", rpc_sockets[i], rpc_fd, pid, buf);
|
2015-10-30 00:57:59 +00:00
|
|
|
for(size_t j=0; j<tcp_connections.size(); j++) {
|
|
|
|
get_path_from_pid(buf, tcp_connections[j]->pid);
|
|
|
|
if(tcp_connections[j]->rpcSock==rpc_sockets[i]){
|
|
|
|
fprintf(stderr, " |\n");
|
2015-11-20 09:08:38 +00:00
|
|
|
fprintf(stderr, " |-Connection(0x%p):\n", tcp_connections[j]);
|
2015-10-30 00:57:59 +00:00
|
|
|
fprintf(stderr, " | path\t\t\t= %s\n", buf);
|
|
|
|
fprintf(stderr, " | perceived_fd\t\t= %d\t(fd)\n", tcp_connections[j]->perceived_fd);
|
|
|
|
fprintf(stderr, " | their_fd\t\t= %d\t(fd)\n", tcp_connections[j]->their_fd);
|
2015-11-20 09:08:38 +00:00
|
|
|
fprintf(stderr, " | dataSock(0x%p)\t= %d\t(fd)\n", tcp_connections[j]->dataSock, _phy.getDescriptor(tcp_connections[j]->dataSock));
|
|
|
|
fprintf(stderr, " | rpcSock(0x%p)\t= %d\t(fd)\n", tcp_connections[j]->rpcSock, _phy.getDescriptor(tcp_connections[j]->rpcSock));
|
2015-10-30 00:57:59 +00:00
|
|
|
fprintf(stderr, " | pending\t\t= %d\n", tcp_connections[j]->pending);
|
|
|
|
fprintf(stderr, " | listening\t\t= %d\n", tcp_connections[j]->listening);
|
2015-11-20 09:08:38 +00:00
|
|
|
fprintf(stderr, " \\------pcb(0x%p)->state\t= %d\n", tcp_connections[j]->pcb, tcp_connections[j]->pcb->state);
|
2015-10-30 00:57:59 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
fprintf(stderr, "\n\ndie(): END SERVICE STATE DUMP\n\n---\n\n");
|
|
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
|
|
* Dumps service state and then exits
|
|
|
|
*/
|
|
|
|
void NetconEthernetTap::die(int exret) {
|
|
|
|
dump();
|
|
|
|
exit(exret);
|
2015-09-10 22:19:43 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 19:23:26 +00:00
|
|
|
/*
|
2015-09-27 10:08:39 +00:00
|
|
|
* Closes a TcpConnection and associated LWIP PCB strcuture.
|
2015-09-23 19:23:26 +00:00
|
|
|
*/
|
2015-09-27 10:08:39 +00:00
|
|
|
void NetconEthernetTap::closeConnection(TcpConnection *conn)
|
|
|
|
{
|
2015-11-02 20:50:32 +00:00
|
|
|
if(!conn)
|
|
|
|
return;
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " closeConnection(%x, %d)\n", conn->pcb, _phy.getDescriptor(conn->dataSock));
|
2015-11-17 03:53:59 +00:00
|
|
|
//lwipstack->_tcp_sent(conn->pcb, NULL);
|
|
|
|
//lwipstack->_tcp_recv(conn->pcb, NULL);
|
|
|
|
//lwipstack->_tcp_err(conn->pcb, NULL);
|
|
|
|
//lwipstack->_tcp_poll(conn->pcb, NULL, 0);
|
2015-10-28 23:18:08 +00:00
|
|
|
//lwipstack->_tcp_arg(conn->pcb, NULL);
|
2015-11-02 20:30:18 +00:00
|
|
|
if(lwipstack->_tcp_close(conn->pcb) != ERR_OK) {
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_ERROR, " closeConnection(): Error while calling tcp_close()\n");
|
2015-11-02 20:30:18 +00:00
|
|
|
exit(0);
|
2015-10-14 19:46:22 +00:00
|
|
|
}
|
2015-11-02 20:30:18 +00:00
|
|
|
else {
|
|
|
|
if(conn->dataSock) {
|
|
|
|
close(_phy.getDescriptor(conn->dataSock));
|
|
|
|
_phy.close(conn->dataSock,false);
|
|
|
|
}
|
|
|
|
/* Eventually we might want to use a map here instead */
|
|
|
|
for(int i=0; i<tcp_connections.size(); i++) {
|
|
|
|
if(tcp_connections[i] == conn) {
|
|
|
|
tcp_connections.erase(tcp_connections.begin() + i);
|
|
|
|
delete conn;
|
|
|
|
break;
|
|
|
|
}
|
2015-09-27 10:08:39 +00:00
|
|
|
}
|
2015-09-24 23:22:56 +00:00
|
|
|
}
|
2015-09-11 18:00:42 +00:00
|
|
|
}
|
|
|
|
|
2015-10-13 01:50:41 +00:00
|
|
|
/*
|
|
|
|
* Close a single RPC connection and associated PhySocket
|
|
|
|
*/
|
2015-09-27 10:08:39 +00:00
|
|
|
void NetconEthernetTap::closeClient(PhySocket *sock)
|
2015-09-22 23:53:36 +00:00
|
|
|
{
|
2015-10-22 23:26:29 +00:00
|
|
|
for(size_t i=0; i<rpc_sockets.size(); i++) {
|
2015-10-14 23:55:21 +00:00
|
|
|
if(rpc_sockets[i] == sock){
|
2015-09-27 10:08:39 +00:00
|
|
|
rpc_sockets.erase(rpc_sockets.begin() + i);
|
2015-10-14 23:55:21 +00:00
|
|
|
break;
|
|
|
|
}
|
2015-09-22 23:53:36 +00:00
|
|
|
}
|
2015-09-27 10:08:39 +00:00
|
|
|
close(_phy.getDescriptor(sock));
|
|
|
|
_phy.close(sock);
|
|
|
|
}
|
|
|
|
|
2015-10-13 01:50:41 +00:00
|
|
|
/*
|
|
|
|
* Close all RPC and TCP connections
|
|
|
|
*/
|
2015-09-27 10:08:39 +00:00
|
|
|
void NetconEthernetTap::closeAll()
|
|
|
|
{
|
|
|
|
while(rpc_sockets.size())
|
|
|
|
closeClient(rpc_sockets.front());
|
|
|
|
while(tcp_connections.size())
|
|
|
|
closeConnection(tcp_connections.front());
|
2015-09-22 23:53:36 +00:00
|
|
|
}
|
2015-09-10 21:44:01 +00:00
|
|
|
|
2015-10-22 23:26:29 +00:00
|
|
|
#include <sys/resource.h>
|
|
|
|
|
2015-09-02 22:17:38 +00:00
|
|
|
void NetconEthernetTap::threadMain()
|
|
|
|
throw()
|
2015-09-02 22:51:28 +00:00
|
|
|
{
|
2015-09-22 17:00:00 +00:00
|
|
|
uint64_t prev_tcp_time = 0;
|
2015-10-16 23:30:01 +00:00
|
|
|
uint64_t prev_status_time = 0;
|
2015-09-22 17:00:00 +00:00
|
|
|
uint64_t prev_etharp_time = 0;
|
2015-09-02 22:51:28 +00:00
|
|
|
|
2015-11-12 22:32:27 +00:00
|
|
|
/*
|
2015-09-21 23:39:26 +00:00
|
|
|
fprintf(stderr, "- MEM_SIZE = %dM\n", MEM_SIZE / (1024*1024));
|
2015-11-04 22:45:26 +00:00
|
|
|
fprintf(stderr, "- PBUF_POOL_SIZE = %d\n", PBUF_POOL_SIZE);
|
|
|
|
fprintf(stderr, "- PBUF_POOL_BUFSIZE = %d\n", PBUF_POOL_BUFSIZE);
|
2015-09-21 23:39:26 +00:00
|
|
|
fprintf(stderr, "- MEMP_NUM_PBUF = %d\n", MEMP_NUM_PBUF);
|
|
|
|
fprintf(stderr, "- MEMP_NUM_TCP_PCB = %d\n", MEMP_NUM_TCP_PCB);
|
|
|
|
fprintf(stderr, "- MEMP_NUM_TCP_PCB_LISTEN = %d\n", MEMP_NUM_TCP_PCB_LISTEN);
|
2015-11-04 22:45:26 +00:00
|
|
|
fprintf(stderr, "- MEMP_NUM_TCP_SEG = %d\n\n", MEMP_NUM_TCP_SEG);
|
|
|
|
|
|
|
|
fprintf(stderr, "- TCP_SND_BUF = %dK\n", TCP_SND_BUF / 1024);
|
|
|
|
fprintf(stderr, "- TCP_SND_QUEUELEN = %d\n\n", TCP_SND_QUEUELEN);
|
|
|
|
|
2015-09-21 23:39:26 +00:00
|
|
|
fprintf(stderr, "- TCP_WND = %d\n", TCP_WND);
|
|
|
|
fprintf(stderr, "- TCP_MSS = %d\n", TCP_MSS);
|
2015-11-04 22:45:26 +00:00
|
|
|
fprintf(stderr, "- TCP_MAXRTX = %d\n", TCP_MAXRTX);
|
|
|
|
fprintf(stderr, "- IP_REASSEMBLY = %d\n\n", IP_REASSEMBLY);
|
2015-09-21 23:39:26 +00:00
|
|
|
fprintf(stderr, "- ARP_TMR_INTERVAL = %d\n", ARP_TMR_INTERVAL);
|
|
|
|
fprintf(stderr, "- TCP_TMR_INTERVAL = %d\n", TCP_TMR_INTERVAL);
|
|
|
|
fprintf(stderr, "- IP_TMR_INTERVAL = %d\n", IP_TMR_INTERVAL);
|
2015-11-12 22:32:27 +00:00
|
|
|
*/
|
2015-09-23 21:55:15 +00:00
|
|
|
|
2015-09-15 22:47:40 +00:00
|
|
|
// Main timer loop
|
2015-09-10 17:56:01 +00:00
|
|
|
while (_run) {
|
2015-09-22 17:00:00 +00:00
|
|
|
uint64_t now = OSUtils::now();
|
|
|
|
uint64_t since_tcp = now - prev_tcp_time;
|
|
|
|
uint64_t since_etharp = now - prev_etharp_time;
|
2015-10-16 23:30:01 +00:00
|
|
|
uint64_t since_status = now - prev_status_time;
|
2015-09-22 17:00:00 +00:00
|
|
|
uint64_t tcp_remaining = ZT_LWIP_TCP_TIMER_INTERVAL;
|
2015-09-22 21:43:20 +00:00
|
|
|
uint64_t etharp_remaining = ARP_TMR_INTERVAL;
|
2015-10-16 23:30:01 +00:00
|
|
|
uint64_t status_remaining = STATUS_TMR_INTERVAL;
|
2015-09-22 17:00:00 +00:00
|
|
|
|
2015-10-30 00:57:59 +00:00
|
|
|
// Connection prunning
|
2015-10-28 23:18:08 +00:00
|
|
|
if (since_status >= STATUS_TMR_INTERVAL) {
|
2015-11-20 09:08:38 +00:00
|
|
|
//compact_dump();
|
2015-10-16 23:30:01 +00:00
|
|
|
prev_status_time = now;
|
2015-11-20 09:08:38 +00:00
|
|
|
status_remaining = STATUS_TMR_INTERVAL - since_status;
|
2015-10-22 23:26:29 +00:00
|
|
|
if(rpc_sockets.size() || tcp_connections.size()) {
|
2015-11-20 09:08:38 +00:00
|
|
|
|
2015-11-17 07:57:19 +00:00
|
|
|
// dump();
|
|
|
|
// Here we will periodically check the list of rpc_sockets for those that
|
|
|
|
// do not currently have any data connection associated with them. If they are
|
|
|
|
// unused, then we will try to read from them, if they fail, we can safely assume
|
|
|
|
// that the client has closed their end and we can close ours
|
2015-10-23 20:37:41 +00:00
|
|
|
for(size_t i = 0; i<tcp_connections.size(); i++) {
|
|
|
|
if(tcp_connections[i]->listening) {
|
2015-10-23 21:23:04 +00:00
|
|
|
char c;
|
|
|
|
if (read(_phy.getDescriptor(tcp_connections[i]->dataSock), &c, 1) < 0) {
|
|
|
|
// Still in listening state
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
// Here we should handle the case there there is incoming data (?)
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " tap_thread(): Listening socketpair closed. Removing RPC connection (%d)\n",
|
2015-10-23 21:23:04 +00:00
|
|
|
_phy.getDescriptor(tcp_connections[i]->dataSock));
|
|
|
|
closeConnection(tcp_connections[i]);
|
|
|
|
}
|
2015-10-22 20:20:50 +00:00
|
|
|
}
|
2015-10-23 20:37:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
for(size_t i=0, associated = 0; i<rpc_sockets.size(); i++, associated = 0) {
|
|
|
|
for(size_t j=0; j<tcp_connections.size(); j++) {
|
|
|
|
if (tcp_connections[j]->rpcSock == rpc_sockets[i])
|
|
|
|
associated++;
|
|
|
|
}
|
|
|
|
if(!associated){
|
|
|
|
// No TCP connections are associated, this is a candidate for removal
|
2015-10-30 00:57:59 +00:00
|
|
|
int fd = _phy.getDescriptor(rpc_sockets[i]);
|
|
|
|
fcntl(fd, F_SETFL, O_NONBLOCK);
|
2015-10-23 21:23:04 +00:00
|
|
|
unsigned char tmpbuf[BUF_SZ];
|
2015-10-30 00:57:59 +00:00
|
|
|
int n;
|
|
|
|
if((n = read(fd,&tmpbuf,BUF_SZ)) < 0) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " tap_thread(): closing RPC (%d)\n", _phy.getDescriptor(rpc_sockets[i]));
|
2015-10-23 20:37:41 +00:00
|
|
|
closeClient(rpc_sockets[i]);
|
|
|
|
}
|
2015-10-30 00:57:59 +00:00
|
|
|
// < 0 is failure
|
|
|
|
// 0 nothing to read, RPC still active
|
|
|
|
// > 0 RPC data read, handle it
|
|
|
|
else if (n > 0) {
|
2015-10-23 20:37:41 +00:00
|
|
|
// Handle RPC call, this is rare
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " tap_thread(): RPC read during connection check (%d bytes)\n", n);
|
2015-10-30 00:57:59 +00:00
|
|
|
phyOnUnixData(rpc_sockets[i],_phy.getuptr(rpc_sockets[i]),&tmpbuf,BUF_SZ);
|
2015-10-22 20:20:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-16 23:30:01 +00:00
|
|
|
}
|
2015-10-30 00:57:59 +00:00
|
|
|
// Main TCP/ETHARP timer section
|
2015-09-22 17:00:00 +00:00
|
|
|
if (since_tcp >= ZT_LWIP_TCP_TIMER_INTERVAL) {
|
|
|
|
prev_tcp_time = now;
|
|
|
|
lwipstack->tcp_tmr();
|
|
|
|
} else {
|
|
|
|
tcp_remaining = ZT_LWIP_TCP_TIMER_INTERVAL - since_tcp;
|
|
|
|
}
|
2015-09-22 21:43:20 +00:00
|
|
|
if (since_etharp >= ARP_TMR_INTERVAL) {
|
2015-09-22 17:00:00 +00:00
|
|
|
prev_etharp_time = now;
|
|
|
|
lwipstack->etharp_tmr();
|
|
|
|
} else {
|
2015-09-22 21:43:20 +00:00
|
|
|
etharp_remaining = ARP_TMR_INTERVAL - since_etharp;
|
2015-09-22 17:00:00 +00:00
|
|
|
}
|
|
|
|
_phy.poll((unsigned long)std::min(tcp_remaining,etharp_remaining));
|
2015-09-02 22:51:28 +00:00
|
|
|
}
|
2015-10-07 00:32:48 +00:00
|
|
|
closeAll();
|
2015-10-22 23:26:29 +00:00
|
|
|
dlclose(lwipstack->_libref);
|
2015-09-02 22:51:28 +00:00
|
|
|
}
|
|
|
|
|
2015-10-28 00:12:32 +00:00
|
|
|
// Unused -- no UDP or TCP from this thread/Phy<>
|
|
|
|
void NetconEthernetTap::phyOnDatagram(PhySocket *sock,void **uptr,const struct sockaddr *from,void *data,unsigned long len) {}
|
|
|
|
void NetconEthernetTap::phyOnTcpConnect(PhySocket *sock,void **uptr,bool success) {}
|
|
|
|
void NetconEthernetTap::phyOnTcpAccept(PhySocket *sockL,PhySocket *sockN,void **uptrL,void **uptrN,const struct sockaddr *from) {}
|
|
|
|
void NetconEthernetTap::phyOnTcpClose(PhySocket *sock,void **uptr) {}
|
|
|
|
void NetconEthernetTap::phyOnTcpData(PhySocket *sock,void **uptr,void *data,unsigned long len) {}
|
|
|
|
void NetconEthernetTap::phyOnTcpWritable(PhySocket *sock,void **uptr) {}
|
|
|
|
|
2015-11-12 22:32:27 +00:00
|
|
|
void NetconEthernetTap::phyOnUnixClose(PhySocket *sock,void **uptr) {
|
|
|
|
dwr(MSG_DEBUG, " phyOnUnixClose(sock=0x%x, uptr=0x%x): fd = %d\n", sock, uptr, _phy.getDescriptor(sock));
|
2015-11-02 20:50:32 +00:00
|
|
|
TcpConnection *conn = (TcpConnection*)*uptr;
|
2015-11-20 09:08:38 +00:00
|
|
|
closeConnection(conn);
|
2015-09-22 22:44:54 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Handles data on a client's data buffer. Data is sent to LWIP to be enqueued.
|
|
|
|
*/
|
2015-09-22 22:44:54 +00:00
|
|
|
void NetconEthernetTap::phyOnFileDescriptorActivity(PhySocket *sock,void **uptr,bool readable,bool writable)
|
|
|
|
{
|
2015-09-23 18:23:36 +00:00
|
|
|
if(readable) {
|
2015-09-27 10:08:39 +00:00
|
|
|
TcpConnection *conn = (TcpConnection*)*uptr;
|
2015-11-17 07:57:19 +00:00
|
|
|
if(conn->dataSock) { // Sometimes a connection may be closed via nc_recved, check first
|
2015-10-16 23:30:01 +00:00
|
|
|
lwipstack->_lock.lock();
|
2015-10-14 19:46:22 +00:00
|
|
|
handle_write(conn);
|
2015-10-16 23:30:01 +00:00
|
|
|
lwipstack->_lock.unlock();
|
2015-10-16 22:02:07 +00:00
|
|
|
}
|
2015-09-22 22:44:54 +00:00
|
|
|
}
|
2015-10-07 00:32:48 +00:00
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "phyOnFileDescriptorActivity(): PhySocket not readable\n");
|
2015-10-07 00:32:48 +00:00
|
|
|
}
|
2015-09-11 00:22:35 +00:00
|
|
|
}
|
2015-09-11 00:34:48 +00:00
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
2015-10-31 00:00:30 +00:00
|
|
|
* Add a new PhySocket for the client connections
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-10-13 01:26:32 +00:00
|
|
|
void NetconEthernetTap::phyOnUnixAccept(PhySocket *sockL,PhySocket *sockN,void **uptrL,void **uptrN) {
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_DEBUG, " phyOnUnixAccept(): accepting new connection\n");
|
2015-10-30 00:57:59 +00:00
|
|
|
if(find(rpc_sockets.begin(), rpc_sockets.end(), sockN) != rpc_sockets.end()){
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " phyOnUnixAccept(): SockN (0x%x) already exists!\n", sockN);
|
2015-10-30 00:57:59 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-09-27 10:08:39 +00:00
|
|
|
rpc_sockets.push_back(sockN);
|
2015-09-02 22:51:28 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Processes incoming data on a client-specific RPC connection
|
|
|
|
*/
|
2015-09-02 22:51:28 +00:00
|
|
|
void NetconEthernetTap::phyOnUnixData(PhySocket *sock,void **uptr,void *data,unsigned long len)
|
|
|
|
{
|
2015-11-12 16:21:05 +00:00
|
|
|
pid_t pid, tid;
|
|
|
|
int rpc_count;
|
2015-11-12 22:32:27 +00:00
|
|
|
char cmd, timestamp[20];
|
2015-11-12 16:21:05 +00:00
|
|
|
void *payload;
|
|
|
|
unload_rpc(data, pid, tid, rpc_count, timestamp, cmd, payload);
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "\n\nRPC: (pid=%d, tid=%d, rpc_count=%d, timestamp=%s, cmd=%d\n", pid, tid, rpc_count, timestamp, cmd);
|
2015-09-10 22:48:45 +00:00
|
|
|
unsigned char *buf = (unsigned char*)data;
|
2015-11-23 20:43:42 +00:00
|
|
|
|
2015-11-12 16:21:05 +00:00
|
|
|
switch(cmd)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-09-11 00:34:48 +00:00
|
|
|
case RPC_SOCKET:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "RPC_SOCKET\n");
|
|
|
|
struct socket_st socket_rpc;
|
|
|
|
memcpy(&socket_rpc, &buf[IDX_PAYLOAD+1], sizeof(struct socket_st));
|
|
|
|
|
|
|
|
if(rpc_count==rpc_counter) {
|
|
|
|
dwr(MSG_ERROR, "Detected repeat RPC.\n");
|
|
|
|
//return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
rpc_counter = rpc_count;
|
|
|
|
}
|
|
|
|
|
|
|
|
TcpConnection * new_conn;
|
|
|
|
if((new_conn = handle_socket(sock, uptr, &socket_rpc))) {
|
|
|
|
pidmap[sock] = pid;
|
|
|
|
new_conn->pid = pid;
|
|
|
|
}
|
2015-09-11 00:34:48 +00:00
|
|
|
break;
|
|
|
|
case RPC_LISTEN:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "RPC_LISTEN\n");
|
2015-09-11 00:34:48 +00:00
|
|
|
struct listen_st listen_rpc;
|
2015-11-12 16:21:05 +00:00
|
|
|
memcpy(&listen_rpc, &buf[IDX_PAYLOAD+1], sizeof(struct listen_st));
|
2015-09-27 10:08:39 +00:00
|
|
|
handle_listen(sock, uptr, &listen_rpc);
|
2015-09-11 00:34:48 +00:00
|
|
|
break;
|
|
|
|
case RPC_BIND:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "RPC_BIND\n");
|
2015-09-11 00:34:48 +00:00
|
|
|
struct bind_st bind_rpc;
|
2015-11-12 16:21:05 +00:00
|
|
|
memcpy(&bind_rpc, &buf[IDX_PAYLOAD+1], sizeof(struct bind_st));
|
2015-09-27 10:08:39 +00:00
|
|
|
handle_bind(sock, uptr, &bind_rpc);
|
2015-09-11 00:34:48 +00:00
|
|
|
break;
|
2015-12-09 20:20:38 +00:00
|
|
|
case RPC_CONNECT:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "RPC_CONNECT\n");
|
2015-09-11 00:34:48 +00:00
|
|
|
struct connect_st connect_rpc;
|
2015-11-12 16:21:05 +00:00
|
|
|
memcpy(&connect_rpc, &buf[IDX_PAYLOAD+1], sizeof(struct connect_st));
|
2015-09-27 10:08:39 +00:00
|
|
|
handle_connect(sock, uptr, &connect_rpc);
|
2015-09-11 00:34:48 +00:00
|
|
|
break;
|
2015-10-28 00:12:32 +00:00
|
|
|
case RPC_MAP:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "RPC_MAP (len = %d)\n", len);
|
2015-11-12 16:21:05 +00:00
|
|
|
int newfd;
|
|
|
|
memcpy(&newfd, &buf[IDX_PAYLOAD+1], sizeof(int));
|
|
|
|
handle_retval(sock, uptr, rpc_count, newfd);
|
2015-09-11 00:34:48 +00:00
|
|
|
break;
|
2015-12-09 20:20:38 +00:00
|
|
|
case RPC_MAP_REQ:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "RPC_MAP_REQ\n");
|
2015-10-28 21:37:46 +00:00
|
|
|
handle_map_request(sock, uptr, buf);
|
|
|
|
break;
|
2015-12-09 20:20:38 +00:00
|
|
|
case RPC_GETSOCKNAME:
|
|
|
|
dwr(MSG_DEBUG, "RPC_GETSOCKNAME\n");
|
|
|
|
struct getsockname_st getsockname_rpc;
|
|
|
|
memcpy(&getsockname_rpc, &buf[IDX_PAYLOAD+1], sizeof(struct getsockname_st));
|
|
|
|
handle_getsockname(sock, uptr, &getsockname_rpc);
|
|
|
|
break;
|
|
|
|
default:
|
2015-12-10 17:24:56 +00:00
|
|
|
dwr(MSG_ERROR, "POSSIBLE RPC CORRUPTION. TRY AGAIN!\n");
|
2015-09-11 00:34:48 +00:00
|
|
|
break;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
2015-09-02 22:51:28 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 19:23:26 +00:00
|
|
|
/*
|
2015-10-14 21:59:11 +00:00
|
|
|
* Send a 'retval' and 'errno' to the client for an RPC over connection->rpcSock
|
2015-09-23 19:23:26 +00:00
|
|
|
*/
|
2015-10-10 00:27:38 +00:00
|
|
|
int NetconEthernetTap::send_return_value(TcpConnection *conn, int retval, int _errno = 0)
|
2015-10-12 23:29:27 +00:00
|
|
|
{
|
|
|
|
if(conn) {
|
|
|
|
int n = send_return_value(_phy.getDescriptor(conn->rpcSock), retval, _errno);
|
|
|
|
if(n > 0)
|
|
|
|
conn->pending = false;
|
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " Unable to send return value to the intercept. Closing connection\n");
|
2015-10-12 23:29:27 +00:00
|
|
|
closeConnection(conn);
|
|
|
|
}
|
|
|
|
return n;
|
|
|
|
}
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
|
|
|
|
int NetconEthernetTap::send_return_value(int fd, int retval, int _errno = 0)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " send_return_value(): fd = %d, retval = %d, errno = %d\n", fd, retval, _errno);
|
2015-10-12 20:38:08 +00:00
|
|
|
int sz = sizeof(char) + sizeof(retval) + sizeof(errno);
|
2015-10-12 23:29:27 +00:00
|
|
|
char retmsg[sz];
|
|
|
|
memset(&retmsg, '\0', sizeof(retmsg));
|
|
|
|
retmsg[0]=RPC_RETVAL;
|
2015-10-12 20:38:08 +00:00
|
|
|
memcpy(&retmsg[1], &retval, sizeof(retval));
|
2015-10-10 00:27:38 +00:00
|
|
|
memcpy(&retmsg[1]+sizeof(retval), &_errno, sizeof(_errno));
|
2015-10-12 23:29:27 +00:00
|
|
|
return write(fd, &retmsg, sz);
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
|
--------------------------------- LWIP callbacks -------------------------------
|
|
|
|
------------------------------------------------------------------------------*/
|
|
|
|
|
2015-09-24 20:01:19 +00:00
|
|
|
// NOTE: these are called from within LWIP, meaning that lwipstack->_lock is ALREADY
|
|
|
|
// locked in this case!
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Callback from LWIP for when a connection has been accepted and the PCB has been
|
|
|
|
* put into an ACCEPT state.
|
|
|
|
*
|
|
|
|
* A socketpair is created, one end is kept and wrapped into a PhySocket object
|
|
|
|
* for use in the main ZT I/O loop, and one end is sent to the client. The client
|
|
|
|
* is then required to tell the service what new file descriptor it has allocated
|
|
|
|
* for this connection. After the mapping is complete, the accepted socket can be
|
|
|
|
* used.
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
|
|
|
* @param associated service state object
|
|
|
|
* @param newly allocated PCB
|
|
|
|
* @param error code
|
|
|
|
* @return ERR_OK if everything is ok, -1 otherwise
|
2015-10-12 23:29:27 +00:00
|
|
|
|
2015-10-13 22:33:56 +00:00
|
|
|
i := should be implemented in intercept lib
|
|
|
|
I := is implemented in intercept lib
|
|
|
|
X := is implemented in service
|
|
|
|
? := required treatment Unknown
|
|
|
|
- := Not needed
|
|
|
|
|
2015-10-12 23:29:27 +00:00
|
|
|
[ ] EAGAIN or EWOULDBLOCK - The socket is marked nonblocking and no connections are present
|
|
|
|
to be accepted. POSIX.1-2001 allows either error to be returned for
|
|
|
|
this case, and does not require these constants to have the same value,
|
|
|
|
so a portable application should check for both possibilities.
|
2015-10-13 21:57:17 +00:00
|
|
|
[I] EBADF - The descriptor is invalid.
|
|
|
|
[I] ECONNABORTED - A connection has been aborted.
|
2015-10-13 00:46:59 +00:00
|
|
|
[i] EFAULT - The addr argument is not in a writable part of the user address space.
|
2015-10-13 23:12:12 +00:00
|
|
|
[-] EINTR - The system call was interrupted by a signal that was caught before a valid connection arrived; see signal(7).
|
2015-10-16 23:30:01 +00:00
|
|
|
[I] EINVAL - Socket is not listening for connections, or addrlen is invalid (e.g., is negative).
|
2015-10-13 22:33:56 +00:00
|
|
|
[I] EINVAL - (accept4()) invalid value in flags.
|
2015-10-13 21:57:17 +00:00
|
|
|
[I] EMFILE - The per-process limit of open file descriptors has been reached.
|
2015-10-12 23:29:27 +00:00
|
|
|
[ ] ENFILE - The system limit on the total number of open files has been reached.
|
2015-10-13 01:26:32 +00:00
|
|
|
[ ] ENOBUFS, ENOMEM - Not enough free memory. This often means that the memory allocation is
|
|
|
|
limited by the socket buffer limits, not by the system memory.
|
2015-10-13 22:33:56 +00:00
|
|
|
[I] ENOTSOCK - The descriptor references a file, not a socket.
|
2015-10-13 21:57:17 +00:00
|
|
|
[I] EOPNOTSUPP - The referenced socket is not of type SOCK_STREAM.
|
2015-10-12 23:29:27 +00:00
|
|
|
[ ] EPROTO - Protocol error.
|
|
|
|
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-11 00:22:35 +00:00
|
|
|
err_t NetconEthernetTap::nc_accept(void *arg, struct tcp_pcb *newpcb, err_t err)
|
|
|
|
{
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_DEBUG, " nc_accept()\n");
|
2015-09-16 00:32:00 +00:00
|
|
|
Larg *l = (Larg*)arg;
|
2015-09-27 10:08:39 +00:00
|
|
|
TcpConnection *conn = l->conn;
|
2015-09-16 00:32:00 +00:00
|
|
|
NetconEthernetTap *tap = l->tap;
|
2015-10-28 23:18:08 +00:00
|
|
|
int listening_fd = tap->_phy.getDescriptor(conn->dataSock);
|
2015-09-27 10:08:39 +00:00
|
|
|
|
|
|
|
if(conn) {
|
2015-12-12 09:28:59 +00:00
|
|
|
ZT_PHY_SOCKFD_TYPE fds[2];
|
|
|
|
if(socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0) {
|
|
|
|
if(errno < 0) {
|
|
|
|
l->tap->send_return_value(conn, -1, errno);
|
|
|
|
dwr(MSG_ERROR, " nc_accept(): unable to create socketpair\n");
|
|
|
|
return ERR_MEM;
|
2015-10-28 23:18:08 +00:00
|
|
|
}
|
2015-12-12 09:28:59 +00:00
|
|
|
}
|
|
|
|
TcpConnection *new_tcp_conn = new TcpConnection();
|
|
|
|
new_tcp_conn->dataSock = tap->_phy.wrapSocket(fds[0], new_tcp_conn);
|
|
|
|
new_tcp_conn->rpcSock = conn->rpcSock;
|
|
|
|
new_tcp_conn->pcb = newpcb;
|
|
|
|
new_tcp_conn->their_fd = fds[1];
|
|
|
|
tap->tcp_connections.push_back(new_tcp_conn);
|
|
|
|
dwr(MSG_DEBUG, " nc_accept(): socketpair = {%d, %d}\n", fds[0], fds[1]);
|
|
|
|
int send_fd = tap->_phy.getDescriptor(conn->rpcSock);
|
|
|
|
|
|
|
|
if(sock_fd_write(listening_fd, fds[1]) < 0){
|
|
|
|
dwr(MSG_ERROR, " nc_accept(%d): error writing signal byte (listen_fd = %d, perceived_fd = %d)\n", listening_fd, send_fd, fds[1]);
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
close(fds[1]); // close other end of socketpair
|
|
|
|
new_tcp_conn->pending = true;
|
|
|
|
}
|
2015-09-27 10:08:39 +00:00
|
|
|
tap->lwipstack->_tcp_arg(newpcb, new Larg(tap, new_tcp_conn));
|
2015-09-24 20:01:19 +00:00
|
|
|
tap->lwipstack->_tcp_recv(newpcb, nc_recved);
|
|
|
|
tap->lwipstack->_tcp_err(newpcb, nc_err);
|
|
|
|
tap->lwipstack->_tcp_sent(newpcb, nc_sent);
|
2015-11-20 09:08:38 +00:00
|
|
|
tap->lwipstack->_tcp_poll(newpcb, nc_poll, 1);
|
2015-10-12 23:29:27 +00:00
|
|
|
tcp_accepted(conn->pcb); // Let lwIP know that it can queue additional incoming connections
|
2015-12-12 09:28:59 +00:00
|
|
|
return ERR_OK;
|
2015-09-16 00:32:00 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-11-12 22:49:20 +00:00
|
|
|
dwr(MSG_ERROR, " nc_accept(%d): can't locate Connection object for PCB.\n", listening_fd);
|
2015-09-16 00:32:00 +00:00
|
|
|
}
|
|
|
|
return -1;
|
2015-09-11 00:22:35 +00:00
|
|
|
}
|
2015-09-10 17:56:01 +00:00
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Callback from LWIP for when data is available to be read from the network.
|
|
|
|
*
|
|
|
|
* Data is in the form of a linked list of struct pbufs, it is then recombined and
|
|
|
|
* send to the client over the associated unix socket.
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
|
|
|
* @param associated service state object
|
|
|
|
* @param allocated PCB
|
|
|
|
* @param chain of pbufs
|
|
|
|
* @param error code
|
|
|
|
* @return ERR_OK if everything is ok, -1 otherwise
|
|
|
|
*
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-10 17:56:01 +00:00
|
|
|
err_t NetconEthernetTap::nc_recved(void *arg, struct tcp_pcb *tpcb, struct pbuf *p, err_t err)
|
|
|
|
{
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " nc_recved()\n");
|
2015-09-11 00:02:13 +00:00
|
|
|
Larg *l = (Larg*)arg;
|
2015-09-10 17:56:01 +00:00
|
|
|
int n;
|
|
|
|
struct pbuf* q = p;
|
2015-09-22 21:43:20 +00:00
|
|
|
|
2015-09-27 10:08:39 +00:00
|
|
|
if(!l->conn) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " nc_recved(): no connection object\n");
|
2015-09-10 17:56:01 +00:00
|
|
|
return ERR_OK; // ?
|
|
|
|
}
|
|
|
|
if(p == NULL) {
|
2015-12-12 09:28:59 +00:00
|
|
|
if(l->conn && !l->conn->listening) {
|
|
|
|
dwr(MSG_INFO, " nc_recved(): closing connection\n");
|
2015-12-14 17:06:58 +00:00
|
|
|
l->tap->closeConnection(l->conn);
|
2015-12-12 09:28:59 +00:00
|
|
|
return ERR_ABRT;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " nc_recved(): can't locate connection via (arg)\n");
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
return err;
|
|
|
|
}
|
|
|
|
q = p;
|
|
|
|
while(p != NULL) { // Cycle through pbufs and write them to the socket
|
|
|
|
if(p->len <= 0)
|
|
|
|
break; // ?
|
2015-09-27 10:08:39 +00:00
|
|
|
if((n = l->tap->_phy.streamSend(l->conn->dataSock,p->payload, p->len)) > 0) {
|
2015-09-10 17:56:01 +00:00
|
|
|
if(n < p->len) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_INFO, " nc_recved(): unable to write entire pbuf to buffer\n");
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
2015-09-27 10:08:39 +00:00
|
|
|
l->tap->lwipstack->_tcp_recved(tpcb, n); // TODO: would it be more efficient to call this once at the end?
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_DEBUG, " nc_recved(): wrote %d bytes to (%d)\n", n, l->tap->_phy.getDescriptor(l->conn->dataSock));
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_INFO, " nc_recved(): No data written to intercept buffer (%d)\n", l->tap->_phy.getDescriptor(l->conn->dataSock));
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
p = p->next;
|
|
|
|
}
|
2015-09-27 10:08:39 +00:00
|
|
|
l->tap->lwipstack->_pbuf_free(q); // free pbufs
|
2015-09-10 17:56:01 +00:00
|
|
|
return ERR_OK;
|
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Callback from LWIP when an internal error is associtated with the given (arg)
|
|
|
|
*
|
|
|
|
* Since the PCB related to this error might no longer exist, only its perviously
|
|
|
|
* associated (arg) is provided to us.
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
|
|
|
* @param associated service state object
|
|
|
|
* @param error code
|
|
|
|
*
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-10 17:56:01 +00:00
|
|
|
void NetconEthernetTap::nc_err(void *arg, err_t err)
|
|
|
|
{
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, "nc_err()\n");
|
2015-09-11 00:02:13 +00:00
|
|
|
Larg *l = (Larg*)arg;
|
2015-10-13 21:37:54 +00:00
|
|
|
if(!l->conn)
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): Connection is NULL!\n");
|
2015-10-13 00:46:59 +00:00
|
|
|
|
2015-10-31 00:00:30 +00:00
|
|
|
switch(err)
|
|
|
|
{
|
|
|
|
case ERR_MEM:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_MEM->ENOMEM\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, ENOMEM);
|
|
|
|
break;
|
|
|
|
case ERR_BUF:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_BUF->ENOBUFS\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, ENOBUFS);
|
|
|
|
break;
|
|
|
|
case ERR_TIMEOUT:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_TIMEOUT->ETIMEDOUT\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, ETIMEDOUT);
|
|
|
|
break;
|
|
|
|
case ERR_RTE:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_RTE->ENETUNREACH\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, ENETUNREACH);
|
|
|
|
break;
|
|
|
|
case ERR_INPROGRESS:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_INPROGRESS->EINPROGRESS\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, EINPROGRESS);
|
|
|
|
break;
|
|
|
|
case ERR_VAL:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_VAL->EINVAL\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, EINVAL);
|
|
|
|
break;
|
|
|
|
case ERR_WOULDBLOCK:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_WOULDBLOCK->EWOULDBLOCK\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, EWOULDBLOCK);
|
|
|
|
break;
|
|
|
|
case ERR_USE:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_USE->EADDRINUSE\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, EADDRINUSE);
|
|
|
|
break;
|
|
|
|
case ERR_ISCONN:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_ISCONN->EISCONN\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, EISCONN);
|
|
|
|
break;
|
|
|
|
case ERR_ABRT:
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): ERR_ABRT->ECONNREFUSED\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->send_return_value(l->conn, -1, ECONNREFUSED);
|
|
|
|
break;
|
|
|
|
|
|
|
|
// FIXME: Below are errors which don't have a standard errno correlate
|
|
|
|
|
|
|
|
case ERR_RST:
|
|
|
|
l->tap->send_return_value(l->conn, -1, -1);
|
|
|
|
break;
|
|
|
|
case ERR_CLSD:
|
|
|
|
l->tap->send_return_value(l->conn, -1, -1);
|
|
|
|
break;
|
|
|
|
case ERR_CONN:
|
|
|
|
l->tap->send_return_value(l->conn, -1, -1);
|
|
|
|
break;
|
|
|
|
case ERR_ARG:
|
|
|
|
l->tap->send_return_value(l->conn, -1, -1);
|
|
|
|
break;
|
|
|
|
case ERR_IF:
|
|
|
|
l->tap->send_return_value(l->conn, -1, -1);
|
|
|
|
break;
|
|
|
|
default:
|
|
|
|
break;
|
|
|
|
}
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, "nc_err(): closing connection\n");
|
2015-10-31 00:00:30 +00:00
|
|
|
l->tap->closeConnection(l->conn);
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
|
2015-10-09 19:05:45 +00:00
|
|
|
/*
|
|
|
|
* Callback from LWIP to do whatever work we might need to do.
|
|
|
|
*
|
|
|
|
* @param associated service state object
|
|
|
|
* @param PCB we're polling on
|
|
|
|
* @return ERR_OK if everything is ok, -1 otherwise
|
|
|
|
*
|
|
|
|
*/
|
|
|
|
err_t NetconEthernetTap::nc_poll(void* arg, struct tcp_pcb *tpcb)
|
|
|
|
{
|
2015-10-22 20:20:50 +00:00
|
|
|
//Larg *l = (Larg*)arg;
|
2015-10-13 18:27:30 +00:00
|
|
|
/*
|
2015-10-09 19:05:45 +00:00
|
|
|
Larg *l = (Larg*)arg;
|
|
|
|
TcpConnection *conn = l->conn;
|
|
|
|
NetconEthernetTap *tap = l->tap;
|
|
|
|
if(conn && conn->idx) // if valid connection and non-zero index (indicating data present)
|
|
|
|
tap->handle_write(conn);
|
2015-10-13 18:27:30 +00:00
|
|
|
*/
|
2015-10-09 19:05:45 +00:00
|
|
|
return ERR_OK;
|
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
2015-10-07 00:32:48 +00:00
|
|
|
* Callback from LWIP to signal that 'len' bytes have successfully been sent.
|
|
|
|
* As a result, we should put our socket back into a notify-on-readability state
|
|
|
|
* since there is now room on the PCB buffer to write to.
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-10-07 00:32:48 +00:00
|
|
|
* NOTE: This could be used to track the amount of data sent by a connection.
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
|
|
|
* @param associated service state object
|
|
|
|
* @param relevant PCB
|
|
|
|
* @param length of data sent
|
|
|
|
* @return ERR_OK if everything is ok, -1 otherwise
|
|
|
|
*
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-10 17:56:01 +00:00
|
|
|
err_t NetconEthernetTap::nc_sent(void* arg, struct tcp_pcb *tpcb, u16_t len)
|
2015-10-16 23:30:01 +00:00
|
|
|
{
|
2015-11-10 03:37:19 +00:00
|
|
|
//dwr(5, " nc_sent()\n");
|
2015-10-07 00:32:48 +00:00
|
|
|
Larg *l = (Larg*)arg;
|
|
|
|
if(len) {
|
2015-11-03 18:30:18 +00:00
|
|
|
l->conn->acked+=len;
|
2015-11-04 02:10:39 +00:00
|
|
|
//dwr("W = %d, A = %d\n", l->conn->written, l->conn->acked);
|
2015-11-10 03:37:19 +00:00
|
|
|
//dwr("ACK = %d\n", len);
|
2015-10-07 00:32:48 +00:00
|
|
|
l->tap->_phy.setNotifyReadable(l->conn->dataSock, true);
|
2015-10-10 00:27:38 +00:00
|
|
|
l->tap->_phy.whack();
|
2015-10-07 00:32:48 +00:00
|
|
|
}
|
2015-09-24 19:30:07 +00:00
|
|
|
return ERR_OK;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Callback from LWIP which sends a return value to the client to signal that
|
|
|
|
* a connection was established for this PCB
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
|
|
|
* @param associated service state object
|
|
|
|
* @param relevant PCB
|
|
|
|
* @param error code
|
|
|
|
* @return ERR_OK if everything is ok, -1 otherwise
|
|
|
|
*
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-10 17:56:01 +00:00
|
|
|
err_t NetconEthernetTap::nc_connected(void *arg, struct tcp_pcb *tpcb, err_t err)
|
|
|
|
{
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " nc_connected()\n");
|
2015-09-11 00:02:13 +00:00
|
|
|
Larg *l = (Larg*)arg;
|
2015-10-13 01:50:41 +00:00
|
|
|
l->tap->send_return_value(l->conn, ERR_OK);
|
2015-09-24 19:30:07 +00:00
|
|
|
return ERR_OK;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
/*------------------------------------------------------------------------------
|
|
|
|
----------------------------- RPC Handler functions ----------------------------
|
|
|
|
------------------------------------------------------------------------------*/
|
|
|
|
|
2015-11-12 22:32:27 +00:00
|
|
|
/* Unpacks the buffer from an RPC command */
|
|
|
|
void NetconEthernetTap::unload_rpc(void *data, pid_t &pid, pid_t &tid, int &rpc_count, char (timestamp[20]), char &cmd, void* &payload)
|
|
|
|
{
|
|
|
|
unsigned char *buf = (unsigned char*)data;
|
2015-12-12 09:28:59 +00:00
|
|
|
memcpy(&pid, &buf[IDX_PID], sizeof(pid_t));
|
|
|
|
memcpy(&tid, &buf[IDX_TID], sizeof(pid_t));
|
|
|
|
memcpy(&rpc_count, &buf[IDX_COUNT], sizeof(int));
|
|
|
|
memcpy(timestamp, &buf[IDX_TIME], 20);
|
|
|
|
memcpy(&cmd, &buf[IDX_PAYLOAD], sizeof(char));
|
2015-11-12 22:32:27 +00:00
|
|
|
}
|
|
|
|
|
2015-10-28 21:37:46 +00:00
|
|
|
/*
|
|
|
|
Responds to a request from the [intercept] to determine whether a local socket is
|
|
|
|
mapped to this service. In other words, how do the intercept's overridden calls
|
|
|
|
tell the difference between regular AF_LOCAL sockets and one of our socketpairs
|
|
|
|
that is used to communicate over the network?
|
|
|
|
*/
|
|
|
|
void NetconEthernetTap::handle_map_request(PhySocket *sock, void **uptr, unsigned char* buf)
|
|
|
|
{
|
2015-11-02 20:30:18 +00:00
|
|
|
dwr(4, " handle_map_request()\n");
|
2015-10-28 21:37:46 +00:00
|
|
|
TcpConnection *conn = (TcpConnection*)*uptr;
|
|
|
|
int req_fd;
|
2015-11-12 16:21:05 +00:00
|
|
|
memcpy(&req_fd, &buf[IDX_PAYLOAD+1], sizeof(req_fd));
|
2015-10-28 21:37:46 +00:00
|
|
|
for(size_t i=0; i<tcp_connections.size(); i++) {
|
|
|
|
if(tcp_connections[i]->rpcSock == conn->rpcSock && tcp_connections[i]->perceived_fd == req_fd){
|
|
|
|
send_return_value(conn, 1, ERR_OK); // True
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_map_request(their=%d): MAPPED (to %d)\n", req_fd,
|
2015-10-28 21:37:46 +00:00
|
|
|
_phy.getDescriptor(tcp_connections[i]->dataSock));
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
send_return_value(conn, 0, ERR_OK); // False
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_map_request(their=%d): NOT MAPPED\n", req_fd);
|
2015-10-28 21:37:46 +00:00
|
|
|
}
|
|
|
|
|
2015-10-13 01:50:41 +00:00
|
|
|
/**
|
|
|
|
* Handles a return value (client's perceived fd) and completes a mapping
|
|
|
|
* so that we know what connection an RPC call should be associated with.
|
|
|
|
*
|
|
|
|
* @param PhySocket associated with this RPC connection
|
|
|
|
* @param structure containing the data and parameters for this client's RPC
|
|
|
|
*
|
|
|
|
*/
|
2015-11-12 16:21:05 +00:00
|
|
|
void NetconEthernetTap::handle_retval(PhySocket *sock, void **uptr, int rpc_count, int newfd)
|
2015-10-13 01:50:41 +00:00
|
|
|
{
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_retval()\n");
|
2015-10-13 01:50:41 +00:00
|
|
|
TcpConnection *conn = (TcpConnection*)*uptr;
|
2015-10-28 00:12:32 +00:00
|
|
|
if(!conn->pending)
|
|
|
|
return;
|
|
|
|
conn->pending = false;
|
2015-11-12 16:21:05 +00:00
|
|
|
conn->perceived_fd = newfd;
|
|
|
|
if(rpc_count==rpc_counter) {
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_ERROR, " handle_retval(): Detected repeat RPC.\n");
|
2015-11-12 16:21:05 +00:00
|
|
|
//return;
|
|
|
|
}
|
2015-11-12 22:32:27 +00:00
|
|
|
else
|
2015-11-23 20:43:42 +00:00
|
|
|
rpc_counter = rpc_count;
|
2015-10-28 00:12:32 +00:00
|
|
|
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_retval(): CONN:%x - Mapping [our=%d -> their=%d]\n",conn,
|
2015-10-28 00:12:32 +00:00
|
|
|
_phy.getDescriptor(conn->dataSock), conn->perceived_fd);
|
|
|
|
|
|
|
|
/* Check for pre-existing connection for this socket ---
|
|
|
|
This block is in response to interesting behaviour from redis-server. A
|
|
|
|
socket is created, setsockopt is called and the socket is set to IPV6 but fails (for now),
|
|
|
|
then it is closed and re-opened and consequently remapped. With two pipes mapped
|
|
|
|
to the same socket, makes it possible that we write to the wrong pipe and fail. So
|
|
|
|
this block merely searches for a possible duplicate mapping and erases it
|
|
|
|
*/
|
|
|
|
for(size_t i=0; i<tcp_connections.size(); i++) {
|
|
|
|
if(tcp_connections[i] == conn)
|
|
|
|
continue;
|
|
|
|
if(tcp_connections[i]->rpcSock == conn->rpcSock) {
|
|
|
|
if(tcp_connections[i]->perceived_fd == conn->perceived_fd) {
|
|
|
|
int n;
|
|
|
|
if((n = send(_phy.getDescriptor(tcp_connections[i]->dataSock), "z", 1, MSG_NOSIGNAL)) < 0) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_retval(): CONN:%x - Socket (%d) already mapped (originally CONN:%x)\n", conn, tcp_connections[i]->perceived_fd, tcp_connections[i]);
|
2015-10-28 00:12:32 +00:00
|
|
|
closeConnection(tcp_connections[i]);
|
|
|
|
}
|
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_retval(): CONN:%x - This socket is mapped to two different pipes (?). Exiting.\n", conn);
|
2015-11-12 16:21:05 +00:00
|
|
|
//die(0); // FIXME: Print service mapping state and exit
|
2015-10-28 00:12:32 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2015-10-13 01:50:41 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-12-09 20:20:38 +00:00
|
|
|
|
|
|
|
/* Return the address that the socket is bound to */
|
|
|
|
void NetconEthernetTap::handle_getsockname(PhySocket *sock, void **uptr, struct getsockname_st *getsockname_rpc)
|
|
|
|
{
|
|
|
|
TcpConnection *conn = getConnectionByTheirFD(sock, getsockname_rpc->sockfd);
|
|
|
|
dwr(MSG_DEBUG, "handle_getsockname(): sockfd = %d\n", getsockname_rpc->sockfd);
|
|
|
|
|
2015-12-12 09:28:59 +00:00
|
|
|
/*
|
|
|
|
int port = conn->addr->sin_port;
|
2015-12-09 20:20:38 +00:00
|
|
|
int ip = conn->addr->sin_addr.s_addr;
|
|
|
|
unsigned char d[4];
|
|
|
|
d[0] = ip & 0xFF;
|
|
|
|
d[1] = (ip >> 8) & 0xFF;
|
|
|
|
d[2] = (ip >> 16) & 0xFF;
|
|
|
|
d[3] = (ip >> 24) & 0xFF;
|
|
|
|
dwr(MSG_ERROR, " handle_getsockname(): returning address: %d.%d.%d.%d: %d\n", d[0],d[1],d[2],d[3], port);
|
2015-12-12 09:28:59 +00:00
|
|
|
*/
|
2015-12-10 17:24:56 +00:00
|
|
|
|
2015-12-09 20:20:38 +00:00
|
|
|
// Assemble address "command" to send to intercept
|
|
|
|
char retmsg[sizeof(struct sockaddr)];
|
|
|
|
memset(&retmsg, '\0', sizeof(retmsg));
|
|
|
|
dwr(MSG_ERROR, " handle_getsockname(): %d\n", sizeof(retmsg));
|
2015-12-12 09:28:59 +00:00
|
|
|
if(conn == NULL) return;
|
|
|
|
memcpy(&retmsg, conn->addr, 1);
|
2015-12-09 20:20:38 +00:00
|
|
|
// Get connection's RPC fd and send structure containing bound address
|
|
|
|
int fd = _phy.getDescriptor(conn->rpcSock);
|
|
|
|
write(fd, &retmsg, sizeof(struct sockaddr));
|
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Handles an RPC to bind an LWIP PCB to a given address and port
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-10-13 01:50:41 +00:00
|
|
|
* @param PhySocket associated with this RPC connection
|
2015-09-23 19:23:26 +00:00
|
|
|
* @param structure containing the data and parameters for this client's RPC
|
|
|
|
*
|
2015-10-10 00:27:38 +00:00
|
|
|
|
2015-10-13 23:12:12 +00:00
|
|
|
i := should be implemented in intercept lib
|
|
|
|
I := is implemented in intercept lib
|
|
|
|
X := is implemented in service
|
|
|
|
? := required treatment Unknown
|
|
|
|
- := Not needed
|
|
|
|
|
2015-10-10 00:27:38 +00:00
|
|
|
[ ] EACCES - The address is protected, and the user is not the superuser.
|
|
|
|
[X] EADDRINUSE - The given address is already in use.
|
2015-10-13 22:33:56 +00:00
|
|
|
[I] EBADF - sockfd is not a valid descriptor.
|
2015-10-12 20:38:08 +00:00
|
|
|
[X] EINVAL - The socket is already bound to an address.
|
2015-10-13 22:33:56 +00:00
|
|
|
[I] ENOTSOCK - sockfd is a descriptor for a file, not a socket.
|
|
|
|
|
2015-10-14 21:59:11 +00:00
|
|
|
[X] ENOMEM - Insufficient kernel memory was available.
|
2015-10-14 00:20:45 +00:00
|
|
|
|
2015-10-13 22:33:56 +00:00
|
|
|
- The following errors are specific to UNIX domain (AF_UNIX) sockets:
|
|
|
|
|
2015-10-13 01:50:41 +00:00
|
|
|
[-] EACCES - Search permission is denied on a component of the path prefix. (See also path_resolution(7).)
|
|
|
|
[-] EADDRNOTAVAIL - A nonexistent interface was requested or the requested address was not local.
|
|
|
|
[-] EFAULT - addr points outside the user's accessible address space.
|
|
|
|
[-] EINVAL - The addrlen is wrong, or the socket was not in the AF_UNIX family.
|
|
|
|
[-] ELOOP - Too many symbolic links were encountered in resolving addr.
|
|
|
|
[-] ENAMETOOLONG - s addr is too long.
|
|
|
|
[-] ENOENT - The file does not exist.
|
|
|
|
[-] ENOTDIR - A component of the path prefix is not a directory.
|
|
|
|
[-] EROFS - The socket inode would reside on a read-only file system.
|
2015-10-10 00:27:38 +00:00
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-27 10:08:39 +00:00
|
|
|
void NetconEthernetTap::handle_bind(PhySocket *sock, void **uptr, struct bind_st *bind_rpc)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-11-23 20:43:42 +00:00
|
|
|
|
2015-09-10 17:56:01 +00:00
|
|
|
struct sockaddr_in *connaddr;
|
|
|
|
connaddr = (struct sockaddr_in *) &bind_rpc->addr;
|
|
|
|
int conn_port = lwipstack->ntohs(connaddr->sin_port);
|
|
|
|
ip_addr_t conn_addr;
|
2015-12-09 20:20:38 +00:00
|
|
|
conn_addr.addr = *((u32_t *)_ips[0].rawIpData());
|
|
|
|
TcpConnection *conn = getConnectionByTheirFD(sock, bind_rpc->sockfd);
|
2015-09-27 10:08:39 +00:00
|
|
|
|
2015-11-17 07:57:19 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_bind(%d)\n", bind_rpc->sockfd);
|
2015-11-12 16:21:05 +00:00
|
|
|
|
2015-09-27 10:08:39 +00:00
|
|
|
if(conn) {
|
|
|
|
if(conn->pcb->state == CLOSED){
|
|
|
|
int err = lwipstack->tcp_bind(conn->pcb, &conn_addr, conn_port);
|
2015-10-10 00:27:38 +00:00
|
|
|
if(err != ERR_OK) {
|
2015-09-23 19:23:26 +00:00
|
|
|
int ip = connaddr->sin_addr.s_addr;
|
|
|
|
unsigned char d[4];
|
|
|
|
d[0] = ip & 0xFF;
|
2015-10-10 00:27:38 +00:00
|
|
|
d[1] = (ip >> 8) & 0xFF;
|
2015-09-23 19:23:26 +00:00
|
|
|
d[2] = (ip >> 16) & 0xFF;
|
|
|
|
d[3] = (ip >> 24) & 0xFF;
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_bind(): error binding to %d.%d.%d.%d : %d\n", d[0],d[1],d[2],d[3], conn_port);
|
|
|
|
dwr(MSG_ERROR, " handle_bind(): err = %d\n", err);
|
2015-10-28 21:37:46 +00:00
|
|
|
|
2015-10-12 20:38:08 +00:00
|
|
|
if(err == ERR_USE)
|
|
|
|
send_return_value(conn, -1, EADDRINUSE);
|
|
|
|
if(err == ERR_MEM)
|
|
|
|
send_return_value(conn, -1, ENOMEM);
|
2015-10-14 21:59:11 +00:00
|
|
|
if(err == ERR_BUF)
|
|
|
|
send_return_value(conn, -1, ENOMEM); // FIXME: Closest match
|
2015-10-12 20:38:08 +00:00
|
|
|
}
|
2015-10-21 23:27:17 +00:00
|
|
|
else
|
2015-12-09 20:20:38 +00:00
|
|
|
{
|
|
|
|
conn->addr = (struct sockaddr_in *) &bind_rpc->addr;
|
2015-10-12 23:29:27 +00:00
|
|
|
send_return_value(conn, ERR_OK, ERR_OK); // Success
|
2015-12-09 20:20:38 +00:00
|
|
|
}
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
2015-10-12 23:29:27 +00:00
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_bind(): PCB (%x) not in CLOSED state. Ignoring BIND request.\n", conn->pcb);
|
2015-10-12 23:29:27 +00:00
|
|
|
send_return_value(conn, -1, EINVAL);
|
|
|
|
}
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
2015-10-14 21:59:11 +00:00
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_bind(): can't locate connection for PCB\n");
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(conn, -1, EBADF);
|
|
|
|
}
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Handles an RPC to put an LWIP PCB into LISTEN mode
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-10-13 01:50:41 +00:00
|
|
|
* @param PhySocket associated with this RPC connection
|
2015-09-23 19:23:26 +00:00
|
|
|
* @param structure containing the data and parameters for this client's RPC
|
|
|
|
*
|
2015-10-12 23:29:27 +00:00
|
|
|
|
2015-10-13 23:12:12 +00:00
|
|
|
i := should be implemented in intercept lib
|
|
|
|
I := is implemented in intercept lib
|
|
|
|
X := is implemented in service
|
|
|
|
? := required treatment Unknown
|
|
|
|
- := Not needed
|
|
|
|
|
|
|
|
[?] EADDRINUSE - Another socket is already listening on the same port.
|
2015-10-14 21:59:11 +00:00
|
|
|
[IX] EBADF - The argument sockfd is not a valid descriptor.
|
2015-10-13 23:12:12 +00:00
|
|
|
[I] ENOTSOCK - The argument sockfd is not a socket.
|
|
|
|
[I] EOPNOTSUPP - The socket is not of a type that supports the listen() operation.
|
2015-10-12 23:29:27 +00:00
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-27 10:08:39 +00:00
|
|
|
void NetconEthernetTap::handle_listen(PhySocket *sock, void **uptr, struct listen_st *listen_rpc)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-11-02 20:30:18 +00:00
|
|
|
dwr(3, " handle_listen(their=%d):\n", listen_rpc->sockfd);
|
2015-10-13 00:46:59 +00:00
|
|
|
TcpConnection *conn = getConnectionByTheirFD(sock, listen_rpc->sockfd);
|
2015-10-28 21:37:46 +00:00
|
|
|
if(!conn){
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_listen(): unable to locate connection object\n");
|
2015-10-28 21:37:46 +00:00
|
|
|
// ? send_return_value(conn, -1, EBADF);
|
|
|
|
return;
|
|
|
|
}
|
2015-11-02 20:30:18 +00:00
|
|
|
dwr(3, " handle_listen(our=%d -> their=%d)\n", _phy.getDescriptor(conn->dataSock), conn->perceived_fd);
|
2015-10-28 21:37:46 +00:00
|
|
|
|
|
|
|
if(conn->pcb->state == LISTEN) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_listen(): PCB is already in listening state.\n");
|
2015-10-28 21:37:46 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
struct tcp_pcb* listening_pcb;
|
2015-10-22 19:40:01 +00:00
|
|
|
|
2015-10-14 21:03:32 +00:00
|
|
|
#ifdef TCP_LISTEN_BACKLOG
|
2015-10-28 21:37:46 +00:00
|
|
|
listening_pcb = lwipstack->tcp_listen_with_backlog(conn->pcb, listen_rpc->backlog);
|
2015-10-14 21:03:32 +00:00
|
|
|
#else
|
2015-10-28 21:37:46 +00:00
|
|
|
listening_pcb = lwipstack->tcp_listen(conn->pcb);
|
2015-10-14 21:03:32 +00:00
|
|
|
#endif
|
2015-10-13 23:12:12 +00:00
|
|
|
|
2015-10-28 21:37:46 +00:00
|
|
|
if(listening_pcb != NULL) {
|
|
|
|
conn->pcb = listening_pcb;
|
|
|
|
lwipstack->tcp_accept(listening_pcb, nc_accept);
|
|
|
|
lwipstack->tcp_arg(listening_pcb, new Larg(this, conn));
|
|
|
|
/* we need to wait for the client to send us the fd allocated on their end
|
|
|
|
for this listening socket */
|
|
|
|
fcntl(_phy.getDescriptor(conn->dataSock), F_SETFL, O_NONBLOCK);
|
|
|
|
conn->listening = true;
|
|
|
|
conn->pending = true;
|
|
|
|
send_return_value(conn, ERR_OK, ERR_OK);
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-10-16 18:43:38 +00:00
|
|
|
/*
|
2015-10-31 00:00:30 +00:00
|
|
|
dwr"handle_listen(): unable to allocate memory for new listening PCB\n");
|
2015-10-28 21:37:46 +00:00
|
|
|
// FIXME: This does not have an equivalent errno value
|
|
|
|
// lwip will reclaim space with a tcp_listen call since a PCB in a LISTEN
|
|
|
|
// state takes up less space. If something goes wrong during the creation of a
|
|
|
|
// new listening socket we should return an error that implies we can't use this
|
|
|
|
// socket, even if the reason isn't describing what really happened internally.
|
|
|
|
// See: http://lwip.wikia.com/wiki/Raw/TCP
|
2015-10-12 23:29:27 +00:00
|
|
|
send_return_value(conn, -1, EBADF);
|
2015-10-16 18:43:38 +00:00
|
|
|
*/
|
|
|
|
}
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Handles an RPC to create a socket (LWIP PCB and associated socketpair)
|
|
|
|
*
|
|
|
|
* A socketpair is created, one end is kept and wrapped into a PhySocket object
|
|
|
|
* for use in the main ZT I/O loop, and one end is sent to the client. The client
|
|
|
|
* is then required to tell the service what new file descriptor it has allocated
|
|
|
|
* for this connection. After the mapping is complete, the socket can be used.
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-10-13 01:50:41 +00:00
|
|
|
* @param PhySocket associated with this RPC connection
|
2015-09-23 19:23:26 +00:00
|
|
|
* @param structure containing the data and parameters for this client's RPC
|
|
|
|
*
|
2015-10-10 00:27:38 +00:00
|
|
|
|
2015-10-13 23:12:12 +00:00
|
|
|
i := should be implemented in intercept lib
|
|
|
|
I := is implemented in intercept lib
|
|
|
|
X := is implemented in service
|
|
|
|
? := required treatment Unknown
|
|
|
|
- := Not needed
|
2015-10-10 00:27:38 +00:00
|
|
|
|
2015-10-13 01:50:41 +00:00
|
|
|
[-] EACCES - Permission to create a socket of the specified type and/or protocol is denied.
|
2015-10-13 23:12:12 +00:00
|
|
|
[I] EAFNOSUPPORT - The implementation does not support the specified address family.
|
|
|
|
[I] EINVAL - Unknown protocol, or protocol family not available.
|
|
|
|
[I] EINVAL - Invalid flags in type.
|
|
|
|
[I] EMFILE - Process file table overflow.
|
2015-10-13 23:27:19 +00:00
|
|
|
[?] ENFILE - The system limit on the total number of open files has been reached.
|
2015-10-13 00:46:59 +00:00
|
|
|
[X] ENOBUFS or ENOMEM - Insufficient memory is available. The socket cannot be created until sufficient resources are freed.
|
2015-10-13 01:50:41 +00:00
|
|
|
[?] EPROTONOSUPPORT - The protocol type or the specified protocol is not supported within this domain.
|
2015-10-10 00:27:38 +00:00
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-10-31 00:00:30 +00:00
|
|
|
TcpConnection * NetconEthernetTap::handle_socket(PhySocket *sock, void **uptr, struct socket_st* socket_rpc)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-10-14 21:59:11 +00:00
|
|
|
int rpc_fd = _phy.getDescriptor(sock);
|
2015-09-27 10:08:39 +00:00
|
|
|
struct tcp_pcb *newpcb = lwipstack->tcp_new();
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_socket(): pcb=%x\n", newpcb);
|
2015-11-20 09:08:38 +00:00
|
|
|
if(newpcb != NULL) {
|
2015-09-22 22:44:54 +00:00
|
|
|
ZT_PHY_SOCKFD_TYPE fds[2];
|
2015-10-13 21:05:11 +00:00
|
|
|
if(socketpair(PF_LOCAL, SOCK_STREAM, 0, fds) < 0) {
|
|
|
|
if(errno < 0) {
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(rpc_fd, -1, errno);
|
2015-10-31 00:00:30 +00:00
|
|
|
return NULL;
|
2015-10-13 21:05:11 +00:00
|
|
|
}
|
|
|
|
}
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_socket(): socketpair = {%d, %d}\n", fds[0], fds[1]);
|
2015-09-27 10:08:39 +00:00
|
|
|
TcpConnection *new_conn = new TcpConnection();
|
|
|
|
new_conn->dataSock = _phy.wrapSocket(fds[0], new_conn);
|
|
|
|
*uptr = new_conn;
|
|
|
|
new_conn->rpcSock = sock;
|
|
|
|
new_conn->pcb = newpcb;
|
2015-11-20 09:08:38 +00:00
|
|
|
new_conn->their_fd = fds[1];
|
2015-09-27 10:08:39 +00:00
|
|
|
tcp_connections.push_back(new_conn);
|
2015-11-20 09:08:38 +00:00
|
|
|
sock_fd_write(_phy.getDescriptor(sock), fds[1]);
|
2015-10-23 20:37:41 +00:00
|
|
|
close(fds[1]); // close other end of socketpair
|
2015-10-14 00:20:45 +00:00
|
|
|
// Once the client tells us what its fd is on the other end, we can then complete the mapping
|
2015-11-20 09:08:38 +00:00
|
|
|
new_conn->pending = true;
|
2015-12-10 17:24:56 +00:00
|
|
|
send_return_value(rpc_fd, 0, ERR_OK);
|
2015-10-31 00:00:30 +00:00
|
|
|
return new_conn;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-10-12 23:29:27 +00:00
|
|
|
sock_fd_write(rpc_fd, -1); // Send a bad fd, to signal error
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_socket(): Memory not available for new PCB\n");
|
2015-10-14 21:03:32 +00:00
|
|
|
send_return_value(rpc_fd, -1, ENOMEM);
|
2015-10-31 00:00:30 +00:00
|
|
|
return NULL;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-23 18:23:36 +00:00
|
|
|
/*
|
|
|
|
* Handles an RPC to connect to a given address and port
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-10-13 01:50:41 +00:00
|
|
|
* @param PhySocket associated with this RPC connection
|
2015-09-23 19:23:26 +00:00
|
|
|
* @param structure containing the data and parameters for this client's RPC
|
2015-10-13 00:46:59 +00:00
|
|
|
|
2015-10-13 23:12:12 +00:00
|
|
|
--- Error handling in this method will only catch problems which are immedately
|
2015-10-13 00:46:59 +00:00
|
|
|
apprent. Some errors will need to be caught in the nc_connected(0 callback
|
|
|
|
|
2015-10-13 23:12:12 +00:00
|
|
|
i := should be implemented in intercept lib
|
|
|
|
I := is implemented in intercept lib
|
|
|
|
X := is implemented in service
|
|
|
|
? := required treatment Unknown
|
|
|
|
- := Not needed
|
|
|
|
|
|
|
|
[-] EACCES - For UNIX domain sockets, which are identified by pathname: Write permission is denied ...
|
2015-10-13 23:27:19 +00:00
|
|
|
[?] EACCES, EPERM - The user tried to connect to a broadcast address without having the socket broadcast flag enabled ...
|
2015-10-14 21:59:11 +00:00
|
|
|
[X] EADDRINUSE - Local address is already in use.
|
2015-10-13 23:27:19 +00:00
|
|
|
[I] EAFNOSUPPORT - The passed address didn't have the correct address family in its sa_family field.
|
2015-10-14 21:59:11 +00:00
|
|
|
[X] EAGAIN - No more free local ports or insufficient entries in the routing cache.
|
2015-10-13 00:46:59 +00:00
|
|
|
[ ] EALREADY - The socket is nonblocking and a previous connection attempt has not yet been completed.
|
2015-10-14 21:59:11 +00:00
|
|
|
[IX] EBADF - The file descriptor is not a valid index in the descriptor table.
|
2015-10-13 00:46:59 +00:00
|
|
|
[ ] ECONNREFUSED - No-one listening on the remote address.
|
|
|
|
[i] EFAULT - The socket structure address is outside the user's address space.
|
|
|
|
[ ] EINPROGRESS - The socket is nonblocking and the connection cannot be completed immediately.
|
2015-10-13 23:12:12 +00:00
|
|
|
[-] EINTR - The system call was interrupted by a signal that was caught.
|
2015-10-13 00:46:59 +00:00
|
|
|
[X] EISCONN - The socket is already connected.
|
2015-10-14 21:59:11 +00:00
|
|
|
[X] ENETUNREACH - Network is unreachable.
|
2015-10-13 23:12:12 +00:00
|
|
|
[I] ENOTSOCK - The file descriptor is not associated with a socket.
|
2015-10-13 01:50:41 +00:00
|
|
|
[X] ETIMEDOUT - Timeout while attempting connection.
|
2015-10-13 00:46:59 +00:00
|
|
|
|
2015-10-14 21:59:11 +00:00
|
|
|
[X] EINVAL - Invalid argument, SVr4, generally makes sense to set this
|
|
|
|
|
2015-09-23 19:23:26 +00:00
|
|
|
*
|
2015-09-23 18:23:36 +00:00
|
|
|
*/
|
2015-09-27 10:08:39 +00:00
|
|
|
void NetconEthernetTap::handle_connect(PhySocket *sock, void **uptr, struct connect_st* connect_rpc)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_DEBUG, " handle_connect()\n");
|
2015-09-27 10:08:39 +00:00
|
|
|
TcpConnection *conn = (TcpConnection*)*uptr;
|
2015-09-10 17:56:01 +00:00
|
|
|
struct sockaddr_in *connaddr;
|
|
|
|
connaddr = (struct sockaddr_in *) &connect_rpc->__addr;
|
|
|
|
int conn_port = lwipstack->ntohs(connaddr->sin_port);
|
|
|
|
ip_addr_t conn_addr = convert_ip((struct sockaddr_in *)&connect_rpc->__addr);
|
|
|
|
|
2015-09-27 10:08:39 +00:00
|
|
|
if(conn != NULL) {
|
2015-10-14 21:59:11 +00:00
|
|
|
lwipstack->tcp_sent(conn->pcb, nc_sent);
|
2015-09-27 10:08:39 +00:00
|
|
|
lwipstack->tcp_recv(conn->pcb, nc_recved);
|
|
|
|
lwipstack->tcp_err(conn->pcb, nc_err);
|
|
|
|
lwipstack->tcp_poll(conn->pcb, nc_poll, APPLICATION_POLL_FREQ);
|
|
|
|
lwipstack->tcp_arg(conn->pcb, new Larg(this, conn));
|
2015-09-10 17:56:01 +00:00
|
|
|
|
|
|
|
int err = 0;
|
2015-09-27 10:08:39 +00:00
|
|
|
if((err = lwipstack->tcp_connect(conn->pcb,&conn_addr,conn_port, nc_connected)) < 0)
|
2015-09-10 17:56:01 +00:00
|
|
|
{
|
2015-10-14 21:59:11 +00:00
|
|
|
if(err == ERR_ISCONN) {
|
|
|
|
send_return_value(conn, -1, EISCONN); // Already in connected state
|
|
|
|
return;
|
|
|
|
}
|
2015-10-13 00:46:59 +00:00
|
|
|
if(err == ERR_USE) {
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(conn, -1, EADDRINUSE); // Already in use
|
2015-10-13 00:46:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if(err == ERR_VAL) {
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(conn, -1, EINVAL); // Invalid ipaddress parameter
|
2015-10-13 00:46:59 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if(err == ERR_RTE) {
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(conn, -1, ENETUNREACH); // No route to host
|
2015-10-13 00:46:59 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-10-14 21:59:11 +00:00
|
|
|
if(err == ERR_BUF) {
|
|
|
|
send_return_value(conn, -1, EAGAIN); // No more ports available
|
|
|
|
return;
|
2015-10-13 00:46:59 +00:00
|
|
|
}
|
|
|
|
if(err == ERR_MEM)
|
|
|
|
{
|
2015-10-14 21:59:11 +00:00
|
|
|
/* Can occur for the following reasons: tcp_enqueue_flags()
|
|
|
|
|
|
|
|
1) tcp_enqueue_flags is always called with either SYN or FIN in flags.
|
|
|
|
We need one available snd_buf byte to do that.
|
|
|
|
This means we can't send FIN while snd_buf==0. A better fix would be to
|
|
|
|
not include SYN and FIN sequence numbers in the snd_buf count.
|
|
|
|
|
|
|
|
2) Cannot allocate new pbuf
|
|
|
|
3) Cannot allocate new TCP segment
|
|
|
|
|
|
|
|
*/
|
|
|
|
send_return_value(conn, -1, EAGAIN); // FIXME: Doesn't describe the problem well, but closest match
|
|
|
|
return;
|
2015-10-13 00:46:59 +00:00
|
|
|
}
|
|
|
|
|
2015-09-10 17:56:01 +00:00
|
|
|
// We should only return a value if failure happens immediately
|
|
|
|
// Otherwise, we still need to wait for a callback from lwIP.
|
|
|
|
// - This is because an ERR_OK from tcp_connect() only verifies
|
|
|
|
// that the SYN packet was enqueued onto the stack properly,
|
|
|
|
// that's it!
|
|
|
|
// - Most instances of a retval for a connect() should happen
|
|
|
|
// in the nc_connect() and nc_err() callbacks!
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_connect(): unable to connect\n");
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(conn, -1, EAGAIN);
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
// Everything seems to be ok, but we don't have enough info to retval
|
2015-09-27 10:08:39 +00:00
|
|
|
conn->pending=true;
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_connect(): could not locate PCB based on their fd\n");
|
2015-10-14 21:59:11 +00:00
|
|
|
send_return_value(conn, -1, EBADF);
|
2015-09-10 17:56:01 +00:00
|
|
|
}
|
|
|
|
}
|
2015-10-08 23:38:29 +00:00
|
|
|
|
|
|
|
|
|
|
|
void NetconEthernetTap::handle_write(TcpConnection *conn)
|
|
|
|
{
|
2015-11-12 22:32:27 +00:00
|
|
|
//dwr(MSG_DEBUG, " handle_write()\n");
|
2015-10-08 23:38:29 +00:00
|
|
|
float max = (float)TCP_SND_BUF;
|
|
|
|
int r;
|
|
|
|
|
|
|
|
if(!conn) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_write(): could not locate connection for this fd\n");
|
2015-10-08 23:38:29 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
if(conn->idx < max) {
|
2015-10-22 20:20:50 +00:00
|
|
|
if(!conn->pcb) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_write(): conn->pcb == NULL. Failed to write.\n");
|
2015-10-22 20:20:50 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-10-08 23:38:29 +00:00
|
|
|
int sndbuf = conn->pcb->snd_buf; // How much we are currently allowed to write to the connection
|
|
|
|
/* PCB send buffer is full,turn off readability notifications for the
|
|
|
|
corresponding PhySocket until nc_sent() is called and confirms that there is
|
|
|
|
now space on the buffer */
|
|
|
|
if(sndbuf == 0) {
|
|
|
|
_phy.setNotifyReadable(conn->dataSock, false);
|
|
|
|
return;
|
|
|
|
}
|
2015-10-23 20:37:41 +00:00
|
|
|
if(!conn->listening)
|
|
|
|
lwipstack->_tcp_output(conn->pcb);
|
2015-10-08 23:38:29 +00:00
|
|
|
|
2015-10-22 19:40:01 +00:00
|
|
|
if(conn->dataSock) {
|
|
|
|
int read_fd = _phy.getDescriptor(conn->dataSock);
|
|
|
|
if((r = read(read_fd, (&conn->buf)+conn->idx, sndbuf)) > 0) {
|
|
|
|
conn->idx += r;
|
|
|
|
/* Writes data pulled from the client's socket buffer to LWIP. This merely sends the
|
|
|
|
* data to LWIP to be enqueued and eventually sent to the network. */
|
|
|
|
if(r > 0) {
|
|
|
|
int sz;
|
|
|
|
// NOTE: this assumes that lwipstack->_lock is locked, either
|
|
|
|
// because we are in a callback or have locked it manually.
|
|
|
|
int err = lwipstack->_tcp_write(conn->pcb, &conn->buf, r, TCP_WRITE_FLAG_COPY);
|
2015-10-23 20:37:41 +00:00
|
|
|
lwipstack->_tcp_output(conn->pcb);
|
2015-10-22 19:40:01 +00:00
|
|
|
if(err != ERR_OK) {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_ERROR, " handle_write(): error while writing to PCB, (err = %d)\n", err);
|
2015-10-22 19:40:01 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
else {
|
|
|
|
sz = (conn->idx)-r;
|
|
|
|
if(sz) {
|
|
|
|
memmove(&conn->buf, (conn->buf+r), sz);
|
|
|
|
}
|
|
|
|
conn->idx -= r;
|
2015-11-04 02:10:39 +00:00
|
|
|
conn->written+=r;
|
2015-10-22 19:40:01 +00:00
|
|
|
return;
|
|
|
|
}
|
2015-10-08 23:38:29 +00:00
|
|
|
}
|
|
|
|
else {
|
2015-11-12 22:32:27 +00:00
|
|
|
dwr(MSG_INFO, " handle_write(): LWIP stack full\n");
|
2015-10-08 23:38:29 +00:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-09-02 22:17:38 +00:00
|
|
|
} // namespace ZeroTier
|