static void listen_thread(unsigned short port)
{
int fd = open_udp_listenfd(port);
fd_set rset;
int ret, cnt;
struct timeval tv;
struct sockaddr_in dev_addr;
socklen_t dev_len = sizeof(dev_addr);
uint8_t rbuf[1024];
uint32_t yes = 1;
struct ip_mreq mreq;
set_broadcast(fd, true);
if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &yes, sizeof(yes)) < 0) {
printf("reuse addr failed\n");
return;
}
#if 1
char ip[32];
for (cnt = 1; cnt <= 100; cnt++) {
snprintf(ip, sizeof(ip), "234.%d.%d.%d", cnt, cnt, cnt);
mreq.imr_multiaddr.s_addr = inet_addr(ip);
mreq.imr_interface.s_addr = htonl(INADDR_ANY);
if (setsockopt(fd, IPPROTO_IP, IP_ADD_MEMBERSHIP, &mreq, sizeof(mreq)) < 0) {
printf("join multicast group failed, %s\n", ip);
return;
}
}
#endif
printf("listen on port %d\n", port);
while (1) {
FD_ZERO(&rset);
FD_SET(fd, &rset);
ret = select(fd+1, &rset, NULL, NULL, NULL);
if (ret < 0) {
printf("select ret=%d", ret);
continue;
}
if (0 == ret) { /* timeout */
printf("listen timeout\n");
break;
}
ret = recvfrom(fd, rbuf, sizeof(rbuf), 0, (struct sockaddr *)&dev_addr, &dev_len);
printf("recv %d bytes from %s\n", ret, inet_ntoa(dev_addr.sin_addr));
//dump_buf(rbuf, ret);
}
return;
}
static int virtual_switch_probe(void)
{
struct sockaddr_in servaddr, devaddr;
socklen_t slen = sizeof(servaddr);
socklen_t devlen = sizeof(devaddr);
uint8_t sbuf[64], rbuf[64];
int ret;
size_t count = 0;
//hsb_debug("probe virtual switch\n");
/* 1.create udp socket */
int sockfd = open_udp_clientfd();
/* 2.send broadcast packet, 192.168.2.255:19001 */
if (get_broadcast_address(sockfd, &servaddr.sin_addr)) {
close(sockfd);
return -1;
}
servaddr.sin_family = AF_INET;
servaddr.sin_port = htons(VIRTUAL_SWITCH_LISTEN_PORT);
set_broadcast(sockfd, true);
memset(sbuf, 0, sizeof(sbuf));
count = 8;
SET_CMD_FIELD(sbuf, 0, uint16_t, VS_CMD_DEVICE_DISCOVER);
SET_CMD_FIELD(sbuf, 2, uint16_t, count);
sendto(sockfd, sbuf, count, 0, (struct sockaddr *)&servaddr, slen);
/* 3.wait for response in 1 second */
struct timeval tv = { 3, 0 };
do {
ret = recvfrom_timeout(sockfd, rbuf, sizeof(rbuf), (struct sockaddr *)&devaddr, &devlen, &tv);
if (ret < count) {
hsb_critical("probe: get err pkt, len=%d\n", ret);
continue;
}
count = 32;
int cmd = GET_CMD_FIELD(rbuf, 0, uint16_t);
int len = GET_CMD_FIELD(rbuf, 2, uint16_t);
if (cmd != VS_CMD_DEVICE_DISCOVER_RESP || len != count) {
hsb_critical("probe: get err pkt, cmd=%x, len=%d\n", cmd, len);
continue;
}
_register_device(&devaddr.sin_addr, (VS_INFO_T *)(rbuf + 8));
} while (tv.tv_sec > 0 && tv.tv_usec > 0);
close(sockfd);
//hsb_debug("probe virtual switch done\n");
return 0;
}
void init_home_channel(){
home_channel_state.chan_num = 0;
home_channel_state.seqno = 0;
home_channel_state.remote_port = UIP_HTONS(LOCAL_PORT);
set_broadcast(&(home_channel_state.remote_addr));
KNOT_EVENT_CONNECT = process_alloc_event();
KNOT_EVENT_COMMAND = process_alloc_event();
KNOT_EVENT_CONNECTED_DEVICE = process_alloc_event();
}
void service_search(ChannelState* state, uint8_t type){
DataPayload *new_dp = &(state->packet);
clean_packet(new_dp);
//dp_complete(new_dp,10,QACK,1);
set_broadcast(&(home_channel_state.remote_addr));
new_dp->hdr.src_chan_num = state->chan_num;
new_dp->hdr.dst_chan_num = 0;
(new_dp)->hdr.cmd = QUERY;
(new_dp)->dhdr.tlen = uip_htons(sizeof(QueryMsg));
PRINTF("%d\n", uip_ntohs((new_dp)->dhdr.tlen));
QueryMsg *q = (QueryMsg *) new_dp->data;
q->type = type;
strcpy(q->name, controller_name);
knot_broadcast(state,new_dp);
state->state = STATE_QUERY;
state->ticks = 100;
}
static void
server_recv_cb(EV_P_ ev_io *w, int revents)
{
server_ctx_t *server_ctx = (server_ctx_t *)w;
struct sockaddr_storage src_addr;
memset(&src_addr, 0, sizeof(struct sockaddr_storage));
buffer_t *buf = ss_malloc(sizeof(buffer_t));
balloc(buf, buf_size);
socklen_t src_addr_len = sizeof(struct sockaddr_storage);
unsigned int offset = 0;
#ifdef MODULE_REDIR
char control_buffer[64] = { 0 };
struct msghdr msg;
memset(&msg, 0, sizeof(struct msghdr));
struct iovec iov[1];
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
msg.msg_name = &src_addr;
msg.msg_namelen = src_addr_len;
msg.msg_control = control_buffer;
msg.msg_controllen = sizeof(control_buffer);
iov[0].iov_base = buf->data;
iov[0].iov_len = buf_size;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
buf->len = recvmsg(server_ctx->fd, &msg, 0);
if (buf->len == -1) {
ERROR("[udp] server_recvmsg");
goto CLEAN_UP;
} else if (buf->len > packet_size) {
if (verbose) {
LOGI("[udp] UDP server_recv_recvmsg fragmentation");
}
}
if (get_dstaddr(&msg, &dst_addr)) {
LOGE("[udp] unable to get dest addr");
goto CLEAN_UP;
}
src_addr_len = msg.msg_namelen;
#else
ssize_t r;
r = recvfrom(server_ctx->fd, buf->data, buf_size,
0, (struct sockaddr *)&src_addr, &src_addr_len);
if (r == -1) {
// error on recv
// simply drop that packet
ERROR("[udp] server_recv_recvfrom");
goto CLEAN_UP;
} else if (r > packet_size) {
if (verbose) {
LOGI("[udp] server_recv_recvfrom fragmentation");
}
}
buf->len = r;
#endif
if (verbose) {
LOGI("[udp] server receive a packet");
}
#ifdef MODULE_REMOTE
tx += buf->len;
int err = server_ctx->crypto->decrypt_all(buf, server_ctx->crypto->cipher, buf_size);
if (err) {
// drop the packet silently
goto CLEAN_UP;
}
#endif
#ifdef MODULE_LOCAL
#if !defined(MODULE_TUNNEL) && !defined(MODULE_REDIR)
#ifdef __ANDROID__
tx += buf->len;
#endif
uint8_t frag = *(uint8_t *)(buf->data + 2);
offset += 3;
#endif
#endif
/*
*
* SOCKS5 UDP Request
* +----+------+------+----------+----------+----------+
* |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
* +----+------+------+----------+----------+----------+
* | 2 | 1 | 1 | Variable | 2 | Variable |
* +----+------+------+----------+----------+----------+
*
* SOCKS5 UDP Response
* +----+------+------+----------+----------+----------+
* |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
* +----+------+------+----------+----------+----------+
* | 2 | 1 | 1 | Variable | 2 | Variable |
* +----+------+------+----------+----------+----------+
*
* shadowsocks UDP Request (before encrypted)
* +------+----------+----------+----------+
* | ATYP | DST.ADDR | DST.PORT | DATA |
* +------+----------+----------+----------+
* | 1 | Variable | 2 | Variable |
* +------+----------+----------+----------+
*
* shadowsocks UDP Response (before encrypted)
* +------+----------+----------+----------+
* | ATYP | DST.ADDR | DST.PORT | DATA |
* +------+----------+----------+----------+
* | 1 | Variable | 2 | Variable |
* +------+----------+----------+----------+
*
* shadowsocks UDP Request and Response (after encrypted)
* +-------+--------------+
* | IV | PAYLOAD |
* +-------+--------------+
* | Fixed | Variable |
* +-------+--------------+
*
*/
#ifdef MODULE_REDIR
char addr_header[512] = { 0 };
int addr_header_len = construct_udprelay_header(&dst_addr, addr_header);
if (addr_header_len == 0) {
LOGE("[udp] failed to parse tproxy addr");
goto CLEAN_UP;
}
// reconstruct the buffer
brealloc(buf, buf->len + addr_header_len, buf_size);
memmove(buf->data + addr_header_len, buf->data, buf->len);
memcpy(buf->data, addr_header, addr_header_len);
buf->len += addr_header_len;
#elif MODULE_TUNNEL
char addr_header[512] = { 0 };
char *host = server_ctx->tunnel_addr.host;
char *port = server_ctx->tunnel_addr.port;
uint16_t port_num = (uint16_t)atoi(port);
uint16_t port_net_num = htons(port_num);
int addr_header_len = 0;
struct cork_ip ip;
if (cork_ip_init(&ip, host) != -1) {
if (ip.version == 4) {
// send as IPv4
struct in_addr host_addr;
memset(&host_addr, 0, sizeof(struct in_addr));
int host_len = sizeof(struct in_addr);
if (dns_pton(AF_INET, host, &host_addr) == -1) {
FATAL("IP parser error");
}
addr_header[addr_header_len++] = 1;
memcpy(addr_header + addr_header_len, &host_addr, host_len);
addr_header_len += host_len;
} else if (ip.version == 6) {
// send as IPv6
struct in6_addr host_addr;
memset(&host_addr, 0, sizeof(struct in6_addr));
int host_len = sizeof(struct in6_addr);
if (dns_pton(AF_INET6, host, &host_addr) == -1) {
FATAL("IP parser error");
}
addr_header[addr_header_len++] = 4;
memcpy(addr_header + addr_header_len, &host_addr, host_len);
addr_header_len += host_len;
} else {
FATAL("IP parser error");
}
} else {
// send as domain
int host_len = strlen(host);
addr_header[addr_header_len++] = 3;
addr_header[addr_header_len++] = host_len;
memcpy(addr_header + addr_header_len, host, host_len);
addr_header_len += host_len;
}
memcpy(addr_header + addr_header_len, &port_net_num, 2);
addr_header_len += 2;
// reconstruct the buffer
brealloc(buf, buf->len + addr_header_len, buf_size);
memmove(buf->data + addr_header_len, buf->data, buf->len);
memcpy(buf->data, addr_header, addr_header_len);
buf->len += addr_header_len;
#else
char host[257] = { 0 };
char port[64] = { 0 };
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
int addr_header_len = parse_udprelay_header(buf->data + offset, buf->len - offset,
host, port, &dst_addr);
if (addr_header_len == 0) {
// error in parse header
goto CLEAN_UP;
}
char *addr_header = buf->data + offset;
#endif
#ifdef MODULE_LOCAL
char *key = hash_key(server_ctx->remote_addr->sa_family, &src_addr);
#else
char *key = hash_key(dst_addr.ss_family, &src_addr);
#endif
struct cache *conn_cache = server_ctx->conn_cache;
remote_ctx_t *remote_ctx = NULL;
cache_lookup(conn_cache, key, HASH_KEY_LEN, (void *)&remote_ctx);
if (remote_ctx != NULL) {
if (sockaddr_cmp(&src_addr, &remote_ctx->src_addr, sizeof(src_addr))) {
remote_ctx = NULL;
}
}
// reset the timer
if (remote_ctx != NULL) {
ev_timer_again(EV_A_ & remote_ctx->watcher);
}
if (remote_ctx == NULL) {
if (verbose) {
#ifdef MODULE_REDIR
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] cache miss: %s <-> %s", dst, src);
#else
LOGI("[udp] cache miss: %s:%s <-> %s", host, port,
get_addr_str((struct sockaddr *)&src_addr));
#endif
}
} else {
if (verbose) {
#ifdef MODULE_REDIR
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] cache hit: %s <-> %s", dst, src);
#else
LOGI("[udp] cache hit: %s:%s <-> %s", host, port,
get_addr_str((struct sockaddr *)&src_addr));
#endif
}
}
#ifdef MODULE_LOCAL
#if !defined(MODULE_TUNNEL) && !defined(MODULE_REDIR)
if (frag) {
LOGE("[udp] drop a message since frag is not 0, but %d", frag);
goto CLEAN_UP;
}
#endif
const struct sockaddr *remote_addr = server_ctx->remote_addr;
const int remote_addr_len = server_ctx->remote_addr_len;
if (remote_ctx == NULL) {
// Bind to any port
int remotefd = create_remote_socket(remote_addr->sa_family == AF_INET6);
if (remotefd < 0) {
ERROR("[udp] udprelay bind() error");
goto CLEAN_UP;
}
setnonblocking(remotefd);
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef IP_TOS
// Set QoS flag
int tos = 46;
setsockopt(remotefd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
#endif
#ifdef SET_INTERFACE
if (server_ctx->iface) {
if (setinterface(remotefd, server_ctx->iface) == -1)
ERROR("setinterface");
}
#endif
#ifdef __ANDROID__
if (vpn) {
if (protect_socket(remotefd) == -1) {
ERROR("protect_socket");
close(remotefd);
goto CLEAN_UP;
}
}
#endif
// Init remote_ctx
remote_ctx = new_remote(remotefd, server_ctx);
remote_ctx->src_addr = src_addr;
remote_ctx->af = remote_addr->sa_family;
remote_ctx->addr_header_len = addr_header_len;
memcpy(remote_ctx->addr_header, addr_header, addr_header_len);
// Add to conn cache
cache_insert(conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
// Start remote io
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
if (offset > 0) {
buf->len -= offset;
memmove(buf->data, buf->data + offset, buf->len);
}
int err = server_ctx->crypto->encrypt_all(buf, server_ctx->crypto->cipher, buf_size);
if (err) {
// drop the packet silently
goto CLEAN_UP;
}
if (buf->len > packet_size) {
if (verbose) {
LOGI("[udp] server_recv_sendto fragmentation");
}
}
int s = sendto(remote_ctx->fd, buf->data, buf->len, 0, remote_addr, remote_addr_len);
if (s == -1) {
ERROR("[udp] server_recv_sendto");
}
#else
int cache_hit = 0;
int need_query = 0;
if (buf->len - addr_header_len > packet_size) {
if (verbose) {
LOGI("[udp] server_recv_sendto fragmentation");
}
}
if (remote_ctx != NULL) {
cache_hit = 1;
// detect destination mismatch
if (remote_ctx->addr_header_len != addr_header_len
|| memcmp(addr_header, remote_ctx->addr_header, addr_header_len) != 0) {
if (dst_addr.ss_family != AF_INET && dst_addr.ss_family != AF_INET6) {
need_query = 1;
}
} else {
memcpy(&dst_addr, &remote_ctx->dst_addr, sizeof(struct sockaddr_storage));
}
} else {
if (dst_addr.ss_family == AF_INET || dst_addr.ss_family == AF_INET6) {
int remotefd = create_remote_socket(dst_addr.ss_family == AF_INET6);
if (remotefd != -1) {
setnonblocking(remotefd);
#ifdef SO_BROADCAST
set_broadcast(remotefd);
#endif
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef IP_TOS
// Set QoS flag
int tos = 46;
setsockopt(remotefd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
#endif
#ifdef SET_INTERFACE
if (server_ctx->iface) {
if (setinterface(remotefd, server_ctx->iface) == -1)
ERROR("setinterface");
}
#endif
remote_ctx = new_remote(remotefd, server_ctx);
remote_ctx->src_addr = src_addr;
remote_ctx->server_ctx = server_ctx;
remote_ctx->addr_header_len = addr_header_len;
memcpy(remote_ctx->addr_header, addr_header, addr_header_len);
memcpy(&remote_ctx->dst_addr, &dst_addr, sizeof(struct sockaddr_storage));
} else {
ERROR("[udp] bind() error");
goto CLEAN_UP;
}
}
}
if (remote_ctx != NULL && !need_query) {
size_t addr_len = get_sockaddr_len((struct sockaddr *)&dst_addr);
int s = sendto(remote_ctx->fd, buf->data + addr_header_len,
buf->len - addr_header_len, 0,
(struct sockaddr *)&dst_addr, addr_len);
if (s == -1) {
ERROR("[udp] sendto_remote");
if (!cache_hit) {
close_and_free_remote(EV_A_ remote_ctx);
}
} else {
if (!cache_hit) {
// Add to conn cache
remote_ctx->af = dst_addr.ss_family;
char *key = hash_key(remote_ctx->af, &remote_ctx->src_addr);
cache_insert(server_ctx->conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
}
} else {
struct addrinfo hints;
memset(&hints, 0, sizeof(struct addrinfo));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
struct query_ctx *query_ctx = new_query_ctx(buf->data + addr_header_len,
buf->len - addr_header_len);
query_ctx->server_ctx = server_ctx;
query_ctx->addr_header_len = addr_header_len;
query_ctx->src_addr = src_addr;
memcpy(query_ctx->addr_header, addr_header, addr_header_len);
if (need_query) {
query_ctx->remote_ctx = remote_ctx;
}
struct ResolvQuery *query = resolv_query(host, query_resolve_cb,
NULL, query_ctx, htons(atoi(port)));
if (query == NULL) {
ERROR("[udp] unable to create DNS query");
close_and_free_query(EV_A_ query_ctx);
goto CLEAN_UP;
}
query_ctx->query = query;
}
#endif
CLEAN_UP:
bfree(buf);
ss_free(buf);
}
static void
query_resolve_cb(struct sockaddr *addr, void *data)
{
struct query_ctx *query_ctx = (struct query_ctx *)data;
struct ev_loop *loop = query_ctx->server_ctx->loop;
if (verbose) {
LOGI("[udp] udns resolved");
}
query_ctx->query = NULL;
if (addr == NULL) {
LOGE("[udp] udns returned an error");
} else {
remote_ctx_t *remote_ctx = query_ctx->remote_ctx;
int cache_hit = 0;
// Lookup in the conn cache
if (remote_ctx == NULL) {
char *key = hash_key(AF_UNSPEC, &query_ctx->src_addr);
cache_lookup(query_ctx->server_ctx->conn_cache, key, HASH_KEY_LEN, (void *)&remote_ctx);
}
if (remote_ctx == NULL) {
int remotefd = create_remote_socket(addr->sa_family == AF_INET6);
if (remotefd != -1) {
setnonblocking(remotefd);
#ifdef SO_BROADCAST
set_broadcast(remotefd);
#endif
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef IP_TOS
// Set QoS flag
int tos = 46;
setsockopt(remotefd, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
#endif
#ifdef SET_INTERFACE
if (query_ctx->server_ctx->iface) {
if (setinterface(remotefd, query_ctx->server_ctx->iface) == -1)
ERROR("setinterface");
}
#endif
remote_ctx = new_remote(remotefd, query_ctx->server_ctx);
remote_ctx->src_addr = query_ctx->src_addr;
remote_ctx->server_ctx = query_ctx->server_ctx;
remote_ctx->addr_header_len = query_ctx->addr_header_len;
memcpy(remote_ctx->addr_header, query_ctx->addr_header,
query_ctx->addr_header_len);
} else {
ERROR("[udp] bind() error");
}
} else {
cache_hit = 1;
}
if (remote_ctx != NULL) {
memcpy(&remote_ctx->dst_addr, addr, sizeof(struct sockaddr_storage));
size_t addr_len = get_sockaddr_len(addr);
int s = sendto(remote_ctx->fd, query_ctx->buf->data, query_ctx->buf->len,
0, addr, addr_len);
if (s == -1) {
ERROR("[udp] sendto_remote");
if (!cache_hit) {
close_and_free_remote(EV_A_ remote_ctx);
}
} else {
if (!cache_hit) {
// Add to conn cache
char *key = hash_key(AF_UNSPEC, &remote_ctx->src_addr);
cache_insert(query_ctx->server_ctx->conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
}
}
}
// clean up
close_and_free_query(EV_A_ query_ctx);
}
static void *_monitor_thread(void *arg)
{
int fd = open_udp_listenfd(VIRTUAL_SWITCH_BOX_LISTEN_PORT);
fd_set rset;
int ret;
struct timeval tv;
struct sockaddr_in mc_addr, dev_addr;
socklen_t mc_len = sizeof(mc_addr);
socklen_t dev_len = sizeof(dev_addr);
uint8_t sbuf[16], rbuf[16];
int cmd_len;
set_broadcast(fd, true);
get_broadcast_address(fd, &mc_addr.sin_addr);
mc_addr.sin_family = AF_INET;
mc_addr.sin_port = htons(VIRTUAL_SWITCH_LISTEN_PORT);
while (1) {
FD_ZERO(&rset);
FD_SET(fd, &rset);
tv.tv_sec = 2;
tv.tv_usec = 0;
ret = select(fd+1, &rset, NULL, NULL, &tv);
if (ret < 0)
continue;
if (0 == ret) { /* timeout, send keep alive */
_remove_timeout_dev();
memset(sbuf, 0, sizeof(sbuf));
cmd_len = 4;
SET_CMD_FIELD(sbuf, 0, uint16_t, VS_CMD_KEEP_ALIVE);
SET_CMD_FIELD(sbuf, 2, uint16_t, cmd_len);
sendto(fd, sbuf, cmd_len, 0, (struct sockaddr *)&mc_addr, mc_len);
continue;
}
cmd_len = 16;
/* get message */
dev_len = sizeof(struct sockaddr_in);
ret = recvfrom(fd, rbuf, cmd_len, 0, (struct sockaddr *)&dev_addr, &dev_len);
if (ret < 4)
continue;
uint16_t cmd = GET_CMD_FIELD(rbuf, 0, uint16_t);
uint16_t len = GET_CMD_FIELD(rbuf, 2, uint16_t);
if (len != ret) {
hsb_debug("error cmd: %d, %d\n", len, ret);
continue;
}
//hsb_debug("get a cmd: %x\n", cmd);
VS_DEV_T *pdev = _find_dev_by_ip(&dev_addr.sin_addr);
if (!pdev) {
probe_dev(virtual_switch_drv.id);
continue;
}
switch (cmd) {
case VS_CMD_KEEP_ALIVE:
{
break;
}
case VS_CMD_STATUS_CHANGED:
{
uint16_t id = GET_CMD_FIELD(rbuf, 4, uint16_t);
uint16_t val = GET_CMD_FIELD(rbuf, 6, uint16_t);
_status_updated(pdev->id, id, val);
break;
}
case VS_CMD_EVENT:
{
uint16_t id = GET_CMD_FIELD(rbuf, 4, uint16_t);
uint16_t param = GET_CMD_FIELD(rbuf, 6, uint16_t);
uint32_t param2 = GET_CMD_FIELD(rbuf, 8, uint32_t);
_event(pdev->id, id, param, param2);
break;
}
default:
break;
}
_refresh_device(pdev);
}
return NULL;
}
void parse_options(int argc, char **argv)
{
int c;
static struct option long_options[] = {
{ "help", no_argument, NULL, 'h' },
{ "version", no_argument, NULL, 'v' },
{ "iface", required_argument, NULL, 'i' },
{ "lifaces", no_argument, NULL, 'I' },
{ "netmask", required_argument, NULL, 'n' },
{ "address", required_argument, NULL, 'A' },
{ "write", required_argument, NULL, 'w' },
{ "read", required_argument, NULL, 'r' },
{ "pcapfilter", required_argument, NULL, 'f' },
{ "reversed", no_argument, NULL, 'R' },
{ "proto", required_argument, NULL, 't' },
{ "plugin", required_argument, NULL, 'P' },
{ "filter", required_argument, NULL, 'F' },
#ifdef HAVE_EC_LUA
{ "lua-script", required_argument, NULL, 0 },
{ "lua-args", required_argument, NULL, 0 },
#endif
{ "superquiet", no_argument, NULL, 'Q' },
{ "quiet", no_argument, NULL, 'q' },
{ "script", required_argument, NULL, 's' },
{ "silent", no_argument, NULL, 'z' },
#ifdef WITH_IPV6
{ "ip6scan", no_argument, NULL, '6' },
#endif
{ "unoffensive", no_argument, NULL, 'u' },
{ "nosslmitm", no_argument, NULL, 'S' },
{ "load-hosts", required_argument, NULL, 'j' },
{ "save-hosts", required_argument, NULL, 'k' },
{ "wifi-key", required_argument, NULL, 'W' },
{ "config", required_argument, NULL, 'a' },
{ "dns", no_argument, NULL, 'd' },
{ "regex", required_argument, NULL, 'e' },
{ "visual", required_argument, NULL, 'V' },
{ "ext-headers", no_argument, NULL, 'E' },
{ "log", required_argument, NULL, 'L' },
{ "log-info", required_argument, NULL, 'l' },
{ "log-msg", required_argument, NULL, 'm' },
{ "compress", no_argument, NULL, 'c' },
{ "text", no_argument, NULL, 'T' },
{ "curses", no_argument, NULL, 'C' },
{ "daemon", no_argument, NULL, 'D' },
{ "gtk", no_argument, NULL, 'G' },
{ "mitm", required_argument, NULL, 'M' },
{ "only-mitm", no_argument, NULL, 'o' },
{ "bridge", required_argument, NULL, 'B' },
{ "broadcast", required_argument, NULL, 'b' },
{ "promisc", no_argument, NULL, 'p' },
{ "gateway", required_argument, NULL, 'Y' },
{ "certificate", required_argument, NULL, 0 },
{ "private-key", required_argument, NULL, 0 },
{ 0 , 0 , 0 , 0}
};
for (c = 0; c < argc; c++)
DEBUG_MSG("parse_options -- [%d] [%s]", c, argv[c]);
/* OPTIONS INITIALIZATION */
GBL_PCAP->promisc = 1;
GBL_FORMAT = &ascii_format;
GBL_OPTIONS->ssl_mitm = 1;
GBL_OPTIONS->broadcast = 0;
GBL_OPTIONS->ssl_cert = NULL;
GBL_OPTIONS->ssl_pkey = NULL;
/* OPTIONS INITIALIZED */
optind = 0;
int option_index = 0;
while ((c = getopt_long (argc, argv, "A:a:bB:CchDdEe:F:f:GhIi:j:k:L:l:M:m:n:oP:pQqiRr:s:STt:uV:vW:w:Y:z6", long_options, &option_index)) != EOF) {
/* used for parsing arguments */
char *opt_end = optarg;
while (opt_end && *opt_end) opt_end++;
/* enable a loaded filter script? */
switch (c) {
case 'M':
set_mitm(optarg);
break;
case 'o':
set_onlymitm();
//select_text_interface();
break;
case 'b':
set_broadcast();
break;
case 'B':
set_iface_bridge(optarg);
break;
case 'p':
set_promisc();
break;
#ifndef JUST_LIBRARY
case 'T':
select_text_interface();
break;
case 'C':
select_curses_interface();
break;
case 'G':
select_gtk_interface();
break;
case 'D':
select_daemon_interface();
break;
#endif
case 'R':
set_reversed();
break;
case 't':
set_proto(optarg);
break;
case 'P':
set_plugin(optarg);
break;
case 'i':
set_iface(optarg);
break;
case 'I':
/* this option is only useful in the text interface */
set_lifaces();
break;
case 'Y':
set_secondary(optarg);
break;
case 'n':
set_netmask(optarg);
break;
case 'A':
set_address(optarg);
break;
case 'r':
set_read_pcap(optarg);
break;
case 'w':
set_write_pcap(optarg);
break;
case 'f':
set_pcap_filter(optarg);
break;
case 'F':
load_filter(opt_end, optarg);
break;
case 'L':
set_loglevel_packet(optarg);
case 'l':
set_loglevel_info(optarg);
break;
case 'm':
set_loglevel_true(optarg);
break;
case 'c':
set_compress();
break;
case 'e':
opt_set_regex(optarg);
break;
case 'Q':
set_superquiet();
/* no break, quiet must be enabled */
case 'q':
set_quiet();
break;
case 's':
set_script(optarg);
break;
case 'z':
set_silent();
break;
#ifdef WITH_IPV6
case '6':
set_ip6scan();
break;
#endif
case 'u':
set_unoffensive();
break;
case 'S':
disable_sslmitm();
break;
case 'd':
set_resolve();
break;
case 'j':
load_hosts(optarg);
break;
case 'k':
save_hosts(optarg);
break;
case 'V':
opt_set_format(optarg);
break;
case 'E':
set_ext_headers();
break;
case 'W':
set_wifi_key(optarg);
break;
case 'a':
set_conf_file(optarg);
break;
case 'h':
ec_usage();
break;
case 'v':
printf("%s %s\n", GBL_PROGRAM, GBL_VERSION);
clean_exit(0);
break;
/* Certificate and private key options */
case 0:
if (!strcmp(long_options[option_index].name, "certificate")) {
GBL_OPTIONS->ssl_cert = strdup(optarg);
} else if (!strcmp(long_options[option_index].name, "private-key")) {
GBL_OPTIONS->ssl_pkey = strdup(optarg);
#ifdef HAVE_EC_LUA
} else if (!strcmp(long_options[option_index].name,"lua-args")) {
ec_lua_cli_add_args(strdup(optarg));
}
else if (!strcmp(long_options[option_index].name,"lua-script")) {
ec_lua_cli_add_script(strdup(optarg));
break;
#endif
} else {
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
clean_exit(-1);
}
break;
case ':': // missing parameter
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
clean_exit(-1);
break;
case '?': // unknown option
fprintf(stdout, "\nTry `%s --help' for more options.\n\n", GBL_PROGRAM);
clean_exit(-1);
break;
}
}
DEBUG_MSG("parse_options: options parsed");
/* TARGET1 and TARGET2 parsing */
if (argv[optind]) {
GBL_OPTIONS->target1 = strdup(argv[optind]);
DEBUG_MSG("TARGET1: %s", GBL_OPTIONS->target1);
if (argv[optind+1]) {
GBL_OPTIONS->target2 = strdup(argv[optind+1]);
DEBUG_MSG("TARGET2: %s", GBL_OPTIONS->target2);
}
}
/* create the list form the TARGET format (MAC/IPrange/PORTrange) */
compile_display_filter();
DEBUG_MSG("parse_options: targets parsed");
/* check for other options */
if (GBL_SNIFF->start == NULL)
set_unified_sniff();
if (GBL_OPTIONS->read && GBL_PCAP->filter)
FATAL_ERROR("Cannot read from file and set a filter on interface");
if (GBL_OPTIONS->read && GBL_SNIFF->type != SM_UNIFIED )
FATAL_ERROR("You can read from a file ONLY in unified sniffing mode !");
if (GBL_OPTIONS->mitm && GBL_SNIFF->type != SM_UNIFIED )
FATAL_ERROR("You can't do mitm attacks in bridged sniffing mode !");
if (GBL_SNIFF->type == SM_BRIDGED && GBL_PCAP->promisc == 0)
FATAL_ERROR("During bridged sniffing the iface must be in promisc mode !");
if (GBL_OPTIONS->quiet && GBL_UI->type != UI_TEXT)
FATAL_ERROR("The quiet option is useful only with text only UI");
if (GBL_OPTIONS->load_hosts && GBL_OPTIONS->save_hosts)
FATAL_ERROR("Cannot load and save at the same time the hosts list...");
if (GBL_OPTIONS->unoffensive && GBL_OPTIONS->mitm)
FATAL_ERROR("Cannot use mitm attacks in unoffensive mode");
if (GBL_OPTIONS->read && GBL_OPTIONS->mitm)
FATAL_ERROR("Cannot use mitm attacks while reading from file");
#ifndef JUST_LIBRARY
if (GBL_UI->init == NULL)
FATAL_ERROR("Please select an User Interface");
#endif
/* force text interface for only mitm attack */
/* Do not select text interface for only MiTM mode
if (GBL_OPTIONS->only_mitm) {
if (GBL_OPTIONS->mitm)
select_text_interface();
else
FATAL_ERROR("Only mitm requires at least one mitm method");
} */
DEBUG_MSG("parse_options: options combination looks good");
return;
}
static void server_recv_cb(EV_P_ ev_io *w, int revents)
{
struct server_ctx *server_ctx = (struct server_ctx *)w;
struct sockaddr_storage src_addr;
memset(&src_addr, 0, sizeof(struct sockaddr_storage));
char *buf = malloc(BUF_SIZE);
socklen_t src_addr_len = sizeof(struct sockaddr_storage);
unsigned int offset = 0;
#ifdef UDPRELAY_REDIR
char control_buffer[64] = { 0 };
struct msghdr msg;
struct iovec iov[1];
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
msg.msg_name = &src_addr;
msg.msg_namelen = src_addr_len;
msg.msg_control = control_buffer;
msg.msg_controllen = sizeof(control_buffer);
iov[0].iov_base = buf;
iov[0].iov_len = BUF_SIZE;
msg.msg_iov = iov;
msg.msg_iovlen = 1;
ssize_t buf_len = recvmsg(server_ctx->fd, &msg, 0);
if (buf_len == -1) {
ERROR("[udp] server_recvmsg");
goto CLEAN_UP;
}
if (get_dstaddr(&msg, &dst_addr)) {
LOGE("[udp] unable to get dest addr");
goto CLEAN_UP;
}
src_addr_len = msg.msg_namelen;
#else
ssize_t buf_len =
recvfrom(server_ctx->fd, buf, BUF_SIZE, 0, (struct sockaddr *)&src_addr,
&src_addr_len);
if (buf_len == -1) {
// error on recv
// simply drop that packet
ERROR("[udp] server_recvfrom");
goto CLEAN_UP;
}
#endif
if (verbose) {
LOGI("[udp] server receive a packet");
}
#ifdef UDPRELAY_REMOTE
tx += buf_len;
buf = ss_decrypt_all(BUF_SIZE, buf, &buf_len, server_ctx->method, server_ctx->auth);
if (buf == NULL) {
ERROR("[udp] server_ss_decrypt_all");
goto CLEAN_UP;
}
#endif
#ifdef UDPRELAY_LOCAL
#if !defined(UDPRELAY_TUNNEL) && !defined(UDPRELAY_REDIR)
uint8_t frag = *(uint8_t *)(buf + 2);
offset += 3;
#endif
#endif
// packet size > default MTU
if (verbose && buf_len > MTU) {
LOGE("[udp] possible ip fragment, size: %d", (int)buf_len);
}
/*
*
* SOCKS5 UDP Request
* +----+------+------+----------+----------+----------+
* |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
* +----+------+------+----------+----------+----------+
* | 2 | 1 | 1 | Variable | 2 | Variable |
* +----+------+------+----------+----------+----------+
*
* SOCKS5 UDP Response
* +----+------+------+----------+----------+----------+
* |RSV | FRAG | ATYP | DST.ADDR | DST.PORT | DATA |
* +----+------+------+----------+----------+----------+
* | 2 | 1 | 1 | Variable | 2 | Variable |
* +----+------+------+----------+----------+----------+
*
* shadowsocks UDP Request (before encrypted)
* +------+----------+----------+----------+-------------+
* | ATYP | DST.ADDR | DST.PORT | DATA | HMAC-SHA1 |
* +------+----------+----------+----------+-------------+
* | 1 | Variable | 2 | Variable | 10 |
* +------+----------+----------+----------+-------------+
*
* If ATYP & ONETIMEAUTH_FLAG(0x10) == 1, Authentication (HMAC-SHA1) is enabled.
*
* The key of HMAC-SHA1 is (IV + KEY) and the input is the whole packet.
* The output of HMAC-SHA is truncated to 10 bytes (leftmost bits).
*
* shadowsocks UDP Response (before encrypted)
* +------+----------+----------+----------+
* | ATYP | DST.ADDR | DST.PORT | DATA |
* +------+----------+----------+----------+
* | 1 | Variable | 2 | Variable |
* +------+----------+----------+----------+
*
* shadowsocks UDP Request and Response (after encrypted)
* +-------+--------------+
* | IV | PAYLOAD |
* +-------+--------------+
* | Fixed | Variable |
* +-------+--------------+
*
*/
#ifdef UDPRELAY_REDIR
char addr_header[256] = { 0 };
int addr_header_len = construct_udprealy_header(&dst_addr, addr_header);
if (addr_header_len == 0) {
LOGE("[udp] failed to parse tproxy addr");
goto CLEAN_UP;
}
// reconstruct the buffer
if (BUF_SIZE < buf_len + addr_header_len) {
buf = realloc(buf, buf_len + addr_header_len);
}
memmove(buf + addr_header_len, buf, buf_len);
memcpy(buf, addr_header, addr_header_len);
buf_len += addr_header_len;
char *key = hash_key(dst_addr.ss_family, &src_addr);
#elif UDPRELAY_TUNNEL
char addr_header[256] = { 0 };
char *host = server_ctx->tunnel_addr.host;
char *port = server_ctx->tunnel_addr.port;
uint16_t port_num = (uint16_t)atoi(port);
uint16_t port_net_num = htons(port_num);
int addr_header_len = 0;
struct cork_ip ip;
if (cork_ip_init(&ip, host) != -1) {
if (ip.version == 4) {
// send as IPv4
struct in_addr host_addr;
int host_len = sizeof(struct in_addr);
if (dns_pton(AF_INET, host, &host_addr) == -1) {
FATAL("IP parser error");
}
addr_header[addr_header_len++] = 1;
memcpy(addr_header + addr_header_len, &host_addr, host_len);
addr_header_len += host_len;
} else if (ip.version == 6) {
// send as IPv6
struct in6_addr host_addr;
int host_len = sizeof(struct in6_addr);
if (dns_pton(AF_INET6, host, &host_addr) == -1) {
FATAL("IP parser error");
}
addr_header[addr_header_len++] = 4;
memcpy(addr_header + addr_header_len, &host_addr, host_len);
addr_header_len += host_len;
} else {
FATAL("IP parser error");
}
} else {
// send as domain
int host_len = strlen(host);
addr_header[addr_header_len++] = 3;
addr_header[addr_header_len++] = host_len;
memcpy(addr_header + addr_header_len, host, host_len);
addr_header_len += host_len;
}
memcpy(addr_header + addr_header_len, &port_net_num, 2);
addr_header_len += 2;
// reconstruct the buffer
if (BUF_SIZE < buf_len + addr_header_len) {
buf = realloc(buf, buf_len + addr_header_len);
}
memmove(buf + addr_header_len, buf, buf_len);
memcpy(buf, addr_header, addr_header_len);
buf_len += addr_header_len;
char *key = hash_key(ip.version == 4 ? AF_INET : AF_INET6, &src_addr);
#else
char host[256] = { 0 };
char port[64] = { 0 };
struct sockaddr_storage dst_addr;
memset(&dst_addr, 0, sizeof(struct sockaddr_storage));
int addr_header_len = parse_udprealy_header(buf + offset, buf_len - offset,
&server_ctx->auth, host, port,
&dst_addr);
if (addr_header_len == 0) {
// error in parse header
goto CLEAN_UP;
}
char *addr_header = buf + offset;
char *key = hash_key(dst_addr.ss_family, &src_addr);
#endif
struct cache *conn_cache = server_ctx->conn_cache;
struct remote_ctx *remote_ctx = NULL;
cache_lookup(conn_cache, key, HASH_KEY_LEN, (void *)&remote_ctx);
if (remote_ctx != NULL) {
if (memcmp(&src_addr, &remote_ctx->src_addr, sizeof(src_addr))) {
remote_ctx = NULL;
}
}
// reset the timer
if (remote_ctx != NULL) {
ev_timer_again(EV_A_ & remote_ctx->watcher);
}
if (remote_ctx == NULL) {
if (verbose) {
#ifdef UDPRELAY_REDIR
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] cache miss: %s <-> %s", dst, src);
#else
LOGI("[udp] cache miss: %s:%s <-> %s", host, port,
get_addr_str((struct sockaddr *)&src_addr));
#endif
}
} else {
if (verbose) {
#ifdef UDPRELAY_REDIR
char src[SS_ADDRSTRLEN];
char dst[SS_ADDRSTRLEN];
strcpy(src, get_addr_str((struct sockaddr *)&src_addr));
strcpy(dst, get_addr_str((struct sockaddr *)&dst_addr));
LOGI("[udp] cache hit: %s <-> %s", dst, src);
#else
LOGI("[udp] cache hit: %s:%s <-> %s", host, port,
get_addr_str((struct sockaddr *)&src_addr));
#endif
}
}
#ifdef UDPRELAY_LOCAL
#if !defined(UDPRELAY_TUNNEL) && !defined(UDPRELAY_REDIR)
if (frag) {
LOGE("[udp] drop a message since frag is not 0, but %d", frag);
goto CLEAN_UP;
}
#endif
const struct sockaddr *remote_addr = server_ctx->remote_addr;
const int remote_addr_len = server_ctx->remote_addr_len;
if (remote_ctx == NULL) {
// Bind to any port
int remotefd = create_remote_socket(remote_addr->sa_family == AF_INET6);
if (remotefd < 0) {
ERROR("[udp] udprelay bind() error");
goto CLEAN_UP;
}
setnonblocking(remotefd);
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef SET_INTERFACE
if (server_ctx->iface) {
setinterface(remotefd, server_ctx->iface);
}
#endif
#ifdef ANDROID
if (vpn) {
if (protect_socket(remotefd) == -1) {
ERROR("protect_socket");
close(remotefd);
goto CLEAN_UP;
}
}
#endif
// Init remote_ctx
remote_ctx = new_remote(remotefd, server_ctx);
remote_ctx->src_addr = src_addr;
remote_ctx->af = remote_addr->sa_family;
remote_ctx->addr_header_len = addr_header_len;
memcpy(remote_ctx->addr_header, addr_header, addr_header_len);
// Add to conn cache
cache_insert(conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
// Start remote io
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
if (offset > 0) {
buf_len -= offset;
memmove(buf, buf + offset, buf_len);
}
if (server_ctx->auth) {
buf[0] |= ONETIMEAUTH_FLAG;
}
buf = ss_encrypt_all(BUF_SIZE, buf, &buf_len, server_ctx->method, server_ctx->auth);
int s = sendto(remote_ctx->fd, buf, buf_len, 0, remote_addr, remote_addr_len);
if (s == -1) {
ERROR("[udp] sendto_remote");
}
#else
int cache_hit = 0;
int need_query = 0;
if (remote_ctx != NULL) {
cache_hit = 1;
// detect destination mismatch
if (remote_ctx->addr_header_len != addr_header_len
|| memcmp(addr_header, remote_ctx->addr_header, addr_header_len) != 0) {
if (dst_addr.ss_family != AF_INET && dst_addr.ss_family != AF_INET6) {
need_query = 1;
}
}
} else {
if (dst_addr.ss_family == AF_INET || dst_addr.ss_family == AF_INET6) {
int remotefd = create_remote_socket(dst_addr.ss_family == AF_INET6);
if (remotefd != -1) {
setnonblocking(remotefd);
#ifdef SO_BROADCAST
set_broadcast(remotefd);
#endif
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef SET_INTERFACE
if (server_ctx->iface) {
setinterface(remotefd, server_ctx->iface);
}
#endif
remote_ctx = new_remote(remotefd, server_ctx);
remote_ctx->src_addr = src_addr;
remote_ctx->server_ctx = server_ctx;
remote_ctx->addr_header_len = addr_header_len;
memcpy(remote_ctx->addr_header, addr_header, addr_header_len);
} else {
ERROR("[udp] bind() error");
goto CLEAN_UP;
}
}
}
if (remote_ctx != NULL && !need_query) {
size_t addr_len = get_sockaddr_len((struct sockaddr *)&dst_addr);
int s = sendto(remote_ctx->fd, buf + addr_header_len,
buf_len - addr_header_len, 0,
(struct sockaddr *)&dst_addr, addr_len);
if (s == -1) {
ERROR("[udp] sendto_remote");
if (!cache_hit) {
close_and_free_remote(EV_A_ remote_ctx);
}
} else {
if (!cache_hit) {
// Add to conn cache
remote_ctx->af = dst_addr.ss_family;
char *key = hash_key(remote_ctx->af, &remote_ctx->src_addr);
cache_insert(server_ctx->conn_cache, key, HASH_KEY_LEN, (void *)remote_ctx);
ev_io_start(EV_A_ & remote_ctx->io);
ev_timer_start(EV_A_ & remote_ctx->watcher);
}
}
} else {
struct addrinfo hints;
memset(&hints, 0, sizeof(hints));
hints.ai_family = AF_UNSPEC;
hints.ai_socktype = SOCK_DGRAM;
hints.ai_protocol = IPPROTO_UDP;
struct query_ctx *query_ctx = new_query_ctx(buf + addr_header_len,
buf_len -
addr_header_len);
query_ctx->server_ctx = server_ctx;
query_ctx->addr_header_len = addr_header_len;
query_ctx->src_addr = src_addr;
memcpy(query_ctx->addr_header, addr_header, addr_header_len);
if (need_query) {
query_ctx->remote_ctx = remote_ctx;
}
struct ResolvQuery *query = resolv_query(host, query_resolve_cb,
NULL, query_ctx, htons(atoi(port)));
if (query == NULL) {
ERROR("[udp] unable to create DNS query");
close_and_free_query(EV_A_ query_ctx);
goto CLEAN_UP;
}
query_ctx->query = query;
}
#endif
CLEAN_UP:
free(buf);
}
static void query_resolve_cb(EV_P_ ev_io *w, int revents)
{
int err;
struct addrinfo *result, *rp;
struct resolve_ctx *resolve_ctx = (struct resolve_ctx *)w;
asyncns_t *asyncns = resolve_ctx->asyncns;
err = asyncns_handle(asyncns);
if (err == ASYNCNS_HANDLE_AGAIN) {
// try again
return;
} else if (err == ASYNCNS_HANDLE_ERROR) {
// asyncns error
FATAL("[udp] asyncns exit unexpectedly.");
}
asyncns_query_t *query = asyncns_getnext(asyncns);
struct query_ctx *query_ctx = (struct query_ctx *)asyncns_getuserdata(
asyncns, query);
if (!asyncns_isdone(asyncns, query)) {
// wait reolver
return;
}
if (verbose) {
LOGD("[udp] asyncns resolved.");
}
query_ctx->query = NULL;
err = asyncns_getaddrinfo_done(asyncns, query, &result);
if (err) {
ERROR("[udp] asysncns_getaddrinfo");
} else {
// Use IPV4 address if possible
for (rp = result; rp != NULL; rp = rp->ai_next) {
if (rp->ai_family == AF_INET) {
break;
}
}
if (rp == NULL) {
rp = result;
}
int remotefd = create_remote_socket(rp->ai_family == AF_INET6);
if (remotefd != -1) {
setnonblocking(remotefd);
#ifdef SO_BROADCAST
set_broadcast(remotefd);
#endif
#ifdef SO_NOSIGPIPE
set_nosigpipe(remotefd);
#endif
#ifdef SET_INTERFACE
if (query_ctx->server_ctx->iface) {
setinterface(remotefd, query_ctx->server_ctx->iface);
}
#endif
struct remote_ctx *remote_ctx = new_remote(remotefd,
query_ctx->server_ctx);
remote_ctx->src_addr = query_ctx->src_addr;
remote_ctx->dst_addr = *((struct sockaddr_storage *)rp->ai_addr);
remote_ctx->server_ctx = query_ctx->server_ctx;
remote_ctx->addr_header_len = query_ctx->addr_header_len;
memcpy(remote_ctx->addr_header, query_ctx->addr_header,
query_ctx->addr_header_len);
size_t addr_len = sizeof(struct sockaddr_in);
if (remote_ctx->dst_addr.ss_family == AF_INET6) {
addr_len = sizeof(struct sockaddr_in6);
}
int s = sendto(remote_ctx->fd, query_ctx->buf, query_ctx->buf_len,
0, (struct sockaddr *)&remote_ctx->dst_addr,
addr_len);
if (s == -1) {
ERROR("[udp] sendto_remote");
close_and_free_remote(EV_A_ remote_ctx);
} else {
// Add to conn cache
char *key = hash_key(remote_ctx->addr_header,
remote_ctx->addr_header_len,
&remote_ctx->src_addr);
cache_insert(query_ctx->server_ctx->conn_cache, key,
(void *)remote_ctx);
ev_io_start(EV_A_ & remote_ctx->io);
}
} else {
ERROR("[udp] bind() error..");
}
}
// clean up
asyncns_freeaddrinfo(result);
close_and_free_query(EV_A_ query_ctx);
}