Merge branch 'master' into dev

pull/47/head
Jeff Becker 6 years ago
commit c30d908893
No known key found for this signature in database
GPG Key ID: F357B3B42F6F9B05

1
.gitignore vendored

@ -39,6 +39,7 @@ vsproject/
daemon.ini
lokinet-win32.exe
lokinet
lokinet.exe
rapidjson/

@ -18,3 +18,12 @@ build:linux:
paths:
- "lokinet"
#build:windows:
# tags:
# - windows
# stage: build
# script:
# - make STATIC_LINK=ON AVX2=OFF JSONRPC=OFF CC=gcc CXX=g++
# artifacts:
# paths:
# - "lokinet.exe"

@ -30,12 +30,16 @@ set(CMAKE_CXX_EXTENSIONS OFF)
# target-specific crypto code paths not
# applicable to the host's FPU -rick
add_compile_options(-Wall -Wextra -Werror -Wno-unknown-pragmas)
# vla are evil
add_compile_options(-Wvla)
add_compile_options($<$<COMPILE_LANGUAGE:CXX>:-fpermissive>)
add_compile_options(-Wno-unused-function -Wno-deprecated-declarations -Wno-unknown-pragmas)
if (WOW64_CROSS_COMPILE OR WIN64_CROSS_COMPILE)
# dynamic linking does this all the time
if(CMAKE_HOST_WIN32)
add_compile_options(-Wno-cast-function-type)
endif()
if (USING_CLANG)
add_compile_options(-Wno-unused-command-line-argument -Wno-c++11-narrowing)
# because clang is insane enough to inline whole sections of the C++ library!
@ -108,8 +112,8 @@ set(CRYPTO_FLAGS -march=native)
set(CMAKE_ASM_FLAGS "-march=native ${CMAKE_ASM_FLAGS} $ENV{ASFLAGS}")
else()
if(WIN32)
set(CRYPTO_FLAGS -march=haswell -mtune=native)
set(CMAKE_ASM_FLAGS "-march=haswell -mtune=native ${CMAKE_ASM_FLAGS} $ENV{ASFLAGS}")
set(CRYPTO_FLAGS -march=core2)
set(CMAKE_ASM_FLAGS "-march=core2 ${CMAKE_ASM_FLAGS} $ENV{ASFLAGS}")
endif()
endif()
endif()
@ -194,7 +198,7 @@ if(UNIX)
endif()
elseif(WIN32)
set(LIBTUNTAP_IMPL ${TT_ROOT}/tuntap-windows.c)
add_definitions(-DWIN32_LEAN_AND_MEAN -DWIN32 -DWINVER=0x500 -D_WIN32_WINNT=0x500)
add_definitions(-DWIN32_LEAN_AND_MEAN -DWIN32 -DWINVER=0x600 -D_WIN32_WINNT=0x600)
else()
message(FATAL_ERROR "What operating system _are_ you building on/for?")
endif(UNIX)

@ -50,11 +50,12 @@ CXX17 ?= ON
AVX2 ?= ON
RPI ?= OFF
STATIC_LINK ?= OFF
CMAKE_GEN ?= Unix Makefiles
BUILD_ROOT = $(REPO)/build
CONFIG_CMD = $(shell /bin/echo -n "cd '$(BUILD_ROOT)' && " ; /bin/echo -n "cmake -DSTATIC_LINK=$(STATIC_LINK) -DUSE_AVX2=$(AVX2) -DUSE_CXX17=$(CXX17) -DUSE_LIBABYSS=$(JSONRPC) -DRPI=$(RPI) '$(REPO)'")
CONFIG_CMD = $(shell /bin/echo -n "cd '$(BUILD_ROOT)' && " ; /bin/echo -n "cmake -G'$(CMAKE_GEN)' -DSTATIC_LINK=$(STATIC_LINK) -DUSE_AVX2=$(AVX2) -DUSE_CXX17=$(CXX17) -DUSE_LIBABYSS=$(JSONRPC) -DRPI=$(RPI) '$(REPO)'")
SCAN_BUILD ?= scan-build
ANALYZE_CONFIG_CMD = $(shell /bin/echo -n "cd '$(BUILD_ROOT)' && " ; /bin/echo -n "$(SCAN_BUILD) cmake -DUSE_LIBABYSS=$(JSONRPC) '$(REPO)'")
@ -161,6 +162,14 @@ android-gradle: android-gradle-prepare
android: android-gradle
windows-configure: clean
mkdir -p '$(BUILD_ROOT)'
$(CONFIG_CMD) -DCMAKE_CROSSCOMPILING=ON -DCMAKE_TOOLCHAIN_FILE='$(REPO)/contrib/cross/mingw.cmake' -DCMAKE_BUILD_TYPE=Release -DCMAKE_C_COMPILER=i686-w64-mingw32-gcc-win32 -DCMAKE_CXX_COMPILER=i686-w64-mingw32-g++-win32 -DDNS_PORT=$(DNS_PORT) -DCMAKE_ASM_FLAGS='$(ASFLAGS)' -DCMAKE_C_FLAGS='$(CFLAGS)' -DCMAKE_CXX_FLAGS='$(CXXFLAGS)'
windows: windows-configure
$(MAKE) -C '$(BUILD_ROOT)'
cp '$(BUILD_ROOT)/lokinet.exe' '$(REPO)/lokinet.exe'
abyss: debug
$(ABYSS_EXE)

@ -582,6 +582,7 @@ randombytes_salsa20_random_buf(void *const buf, const size_t size)
stream.nonce++;
crypto_stream_salsa20_xor(stream.key, stream.key, sizeof stream.key,
(unsigned char *)&stream.nonce, stream.key);
(void)ret;
}
/*
@ -616,7 +617,7 @@ randombytes_salsa20_random(void)
stream.rnd32_outleft -= sizeof val;
memcpy(&val, &stream.rnd32[stream.rnd32_outleft], sizeof val);
memset(&stream.rnd32[stream.rnd32_outleft], 0, sizeof val);
(void)ret;
return val;
}

@ -4,27 +4,35 @@
#include "r3.h"
/* caller must ensure that x-y does not overflow */
static int smaller_mask(int x,int y)
static int
smaller_mask(int x, int y)
{
return (x - y) >> 31;
}
static void vectormod3_product(small *z,int len,const small *x,const small c)
static void
vectormod3_product(small *z, int len, const small *x, const small c)
{
int i;
for (i = 0;i < len;++i) z[i] = mod3_product(x[i],c);
for(i = 0; i < len; ++i)
z[i] = mod3_product(x[i], c);
}
static void vectormod3_minusproduct(small *z,int len,const small *x,const small *y,const small c)
static void
vectormod3_minusproduct(small *z, int len, const small *x, const small *y,
const small c)
{
int i;
for (i = 0;i < len;++i) z[i] = mod3_minusproduct(x[i],y[i],c);
for(i = 0; i < len; ++i)
z[i] = mod3_minusproduct(x[i], y[i], c);
}
static void vectormod3_shift(small *z,int len)
static void
vectormod3_shift(small *z, int len)
{
int i;
for (i = len - 1;i > 0;--i) z[i] = z[i - 1];
for(i = len - 1; i > 0; --i)
z[i] = z[i - 1];
z[0] = 0;
}
@ -34,42 +42,45 @@ or returning -1 if s is not invertible mod m
r,s are polys of degree <p
m is x^p-x-1
*/
int r3_recip(small *r,const small *s)
#define LOOPS (2 * p + 1)
int
r3_recip(small *r, const small *s)
{
const int loops = 2*p + 1;
int loop;
small f[p + 1];
small g[p + 1];
#ifdef _MSC_VER
small f[p + 1];
small g[p + 1];
small u[LOOPS + 1];
small v[LOOPS + 1];
#else
small u[loops + 1];
small v[loops + 1];
#endif
small c;
int i;
int d = p;
int e = p;
int swapmask;
for (i = 2;i < p;++i) f[i] = 0;
for(i = 2; i < p; ++i)
f[i] = 0;
f[0] = -1;
f[1] = -1;
f[p] = 1;
/* generalization: can initialize f to any polynomial m */
/* requirements: m has degree exactly p, nonzero constant coefficient */
for (i = 0;i < p;++i) g[i] = s[i];
for(i = 0; i < p; ++i)
g[i] = s[i];
g[p] = 0;
for (i = 0;i <= loops;++i) u[i] = 0;
for(i = 0; i <= LOOPS; ++i)
u[i] = 0;
v[0] = 1;
for (i = 1;i <= loops;++i) v[i] = 0;
for(i = 1; i <= LOOPS; ++i)
v[i] = 0;
loop = 0;
for (;;) {
for(;;)
{
/* e == -1 or d + e + loop <= 2*p */
/* f has degree p: i.e., f[p]!=0 */
@ -80,29 +91,35 @@ int r3_recip(small *r,const small *s)
/* u has degree <=loop (so it fits in loop+1 coefficients) */
/* u[i]==0 for i < p-d */
/* if invertible: u[i]==0 for i < loop-p (so can look at just p+1 coefficients) */
/* if invertible: u[i]==0 for i < loop-p (so can look at just p+1
* coefficients) */
/* v has degree <=loop (so it fits in loop+1 coefficients) */
/* v[i]==0 for i < p-e */
/* v[i]==0 for i < loop-p (so can look at just p+1 coefficients) */
if (loop >= loops) break;
if(loop >= LOOPS)
break;
c = mod3_quotient(g[p],f[p]);
c = mod3_quotient(g[p], f[p]);
vectormod3_minusproduct(g,p + 1,g,f,c);
vectormod3_shift(g,p + 1);
vectormod3_minusproduct(g, p + 1, g, f, c);
vectormod3_shift(g, p + 1);
#ifdef SIMPLER
vectormod3_minusproduct(v,loops + 1,v,u,c);
vectormod3_shift(v,loops + 1);
vectormod3_minusproduct(v, loops + 1, v, u, c);
vectormod3_shift(v, loops + 1);
#else
if (loop < p) {
vectormod3_minusproduct(v,loop + 1,v,u,c);
vectormod3_shift(v,loop + 2);
} else {
vectormod3_minusproduct(v + loop - p,p + 1,v + loop - p,u + loop - p,c);
vectormod3_shift(v + loop - p,p + 2);
if(loop < p)
{
vectormod3_minusproduct(v, loop + 1, v, u, c);
vectormod3_shift(v, loop + 2);
}
else
{
vectormod3_minusproduct(v + loop - p, p + 1, v + loop - p, u + loop - p,
c);
vectormod3_shift(v + loop - p, p + 2);
}
#endif
@ -110,22 +127,25 @@ int r3_recip(small *r,const small *s)
++loop;
swapmask = smaller_mask(e,d) & mod3_nonzero_mask(g[p]);
swap(&e,&d,sizeof e,swapmask);
swap(f,g,(p + 1) * sizeof(small),swapmask);
swapmask = smaller_mask(e, d) & mod3_nonzero_mask(g[p]);
swap(&e, &d, sizeof e, swapmask);
swap(f, g, (p + 1) * sizeof(small), swapmask);
#ifdef SIMPLER
swap(u,v,(loops + 1) * sizeof(small),swapmask);
swap(u, v, (loops + 1) * sizeof(small), swapmask);
#else
if (loop < p) {
swap(u,v,(loop + 1) * sizeof(small),swapmask);
} else {
swap(u + loop - p,v + loop - p,(p + 1) * sizeof(small),swapmask);
if(loop < p)
{
swap(u, v, (loop + 1) * sizeof(small), swapmask);
}
else
{
swap(u + loop - p, v + loop - p, (p + 1) * sizeof(small), swapmask);
}
#endif
}
c = mod3_reciprocal(f[p]);
vectormod3_product(r,p,u + p,c);
return smaller_mask(0,d);
vectormod3_product(r, p, u + p, c);
return smaller_mask(0, d);
}

@ -3,27 +3,35 @@
#include "rq.h"
/* caller must ensure that x-y does not overflow */
static int smaller_mask(int x,int y)
static int
smaller_mask(int x, int y)
{
return (x - y) >> 31;
}
static void vectormodq_product(modq *z,int len,const modq *x,const modq c)
static void
vectormodq_product(modq *z, int len, const modq *x, const modq c)
{
int i;
for (i = 0;i < len;++i) z[i] = modq_product(x[i],c);
for(i = 0; i < len; ++i)
z[i] = modq_product(x[i], c);
}
static void vectormodq_minusproduct(modq *z,int len,const modq *x,const modq *y,const modq c)
static void
vectormodq_minusproduct(modq *z, int len, const modq *x, const modq *y,
const modq c)
{
int i;
for (i = 0;i < len;++i) z[i] = modq_minusproduct(x[i],y[i],c);
for(i = 0; i < len; ++i)
z[i] = modq_minusproduct(x[i], y[i], c);
}
static void vectormodq_shift(modq *z,int len)
static void
vectormodq_shift(modq *z, int len)
{
int i;
for (i = len - 1;i > 0;--i) z[i] = z[i - 1];
for(i = len - 1; i > 0; --i)
z[i] = z[i - 1];
z[0] = 0;
}
@ -33,42 +41,46 @@ or returning -1 if s is not invertible mod m
r,s are polys of degree <p
m is x^p-x-1
*/
int rq_recip3(modq *r,const small *s)
#define LOOPS (2 * p + 1)
int
rq_recip3(modq *r, const small *s)
{
const int loops = 2*p + 1;
int loop;
modq f[p + 1];
modq g[p + 1];
#ifdef _MSC_VER
modq f[p + 1];
modq g[p + 1];
modq u[LOOPS + 1];
modq v[LOOPS + 1];
#else
modq u[loops + 1];
modq v[loops + 1];
#endif
modq c;
int i;
int d = p;
int e = p;
int swapmask;
for (i = 2;i < p;++i) f[i] = 0;
for(i = 2; i < p; ++i)
f[i] = 0;
f[0] = -1;
f[1] = -1;
f[p] = 1;
/* generalization: can initialize f to any polynomial m */
/* requirements: m has degree exactly p, nonzero constant coefficient */
for (i = 0;i < p;++i) g[i] = 3 * s[i];
for(i = 0; i < p; ++i)
g[i] = 3 * s[i];
g[p] = 0;
for (i = 0;i <= loops;++i) u[i] = 0;
for(i = 0; i <= LOOPS; ++i)
u[i] = 0;
v[0] = 1;
for (i = 1;i <= loops;++i) v[i] = 0;
for(i = 1; i <= LOOPS; ++i)
v[i] = 0;
loop = 0;
for (;;) {
for(;;)
{
/* e == -1 or d + e + loop <= 2*p */
/* f has degree p: i.e., f[p]!=0 */
@ -79,29 +91,35 @@ int rq_recip3(modq *r,const small *s)
/* u has degree <=loop (so it fits in loop+1 coefficients) */
/* u[i]==0 for i < p-d */
/* if invertible: u[i]==0 for i < loop-p (so can look at just p+1 coefficients) */
/* if invertible: u[i]==0 for i < loop-p (so can look at just p+1
* coefficients) */
/* v has degree <=loop (so it fits in loop+1 coefficients) */
/* v[i]==0 for i < p-e */
/* v[i]==0 for i < loop-p (so can look at just p+1 coefficients) */
if (loop >= loops) break;
if(loop >= LOOPS)
break;
c = modq_quotient(g[p],f[p]);
c = modq_quotient(g[p], f[p]);
vectormodq_minusproduct(g,p + 1,g,f,c);
vectormodq_shift(g,p + 1);
vectormodq_minusproduct(g, p + 1, g, f, c);
vectormodq_shift(g, p + 1);
#ifdef SIMPLER
vectormodq_minusproduct(v,loops + 1,v,u,c);
vectormodq_shift(v,loops + 1);
vectormodq_minusproduct(v, loops + 1, v, u, c);
vectormodq_shift(v, loops + 1);
#else
if (loop < p) {
vectormodq_minusproduct(v,loop + 1,v,u,c);
vectormodq_shift(v,loop + 2);
} else {
vectormodq_minusproduct(v + loop - p,p + 1,v + loop - p,u + loop - p,c);
vectormodq_shift(v + loop - p,p + 2);
if(loop < p)
{
vectormodq_minusproduct(v, loop + 1, v, u, c);
vectormodq_shift(v, loop + 2);
}
else
{
vectormodq_minusproduct(v + loop - p, p + 1, v + loop - p, u + loop - p,
c);
vectormodq_shift(v + loop - p, p + 2);
}
#endif
@ -109,22 +127,25 @@ int rq_recip3(modq *r,const small *s)
++loop;
swapmask = smaller_mask(e,d) & modq_nonzero_mask(g[p]);
swap(&e,&d,sizeof e,swapmask);
swap(f,g,(p + 1) * sizeof(modq),swapmask);
swapmask = smaller_mask(e, d) & modq_nonzero_mask(g[p]);
swap(&e, &d, sizeof e, swapmask);
swap(f, g, (p + 1) * sizeof(modq), swapmask);
#ifdef SIMPLER
swap(u,v,(loops + 1) * sizeof(modq),swapmask);
swap(u, v, (loops + 1) * sizeof(modq), swapmask);
#else
if (loop < p) {
swap(u,v,(loop + 1) * sizeof(modq),swapmask);
} else {
swap(u + loop - p,v + loop - p,(p + 1) * sizeof(modq),swapmask);
if(loop < p)
{
swap(u, v, (loop + 1) * sizeof(modq), swapmask);
}
else
{
swap(u + loop - p, v + loop - p, (p + 1) * sizeof(modq), swapmask);
}
#endif
}
c = modq_reciprocal(f[p]);
vectormodq_product(r,p,u + p,c);
return smaller_mask(0,d);
vectormodq_product(r, p, u + p, c);
return smaller_mask(0, d);
}

@ -61,7 +61,7 @@ namespace llarp
operator<<(std::ostream& out, const AddressInfo& a)
{
char tmp[128] = {0};
inet_ntop(AF_INET6, &a.ip, tmp, sizeof(tmp));
inet_ntop(AF_INET6, (void*)&a.ip, tmp, sizeof(tmp));
out << tmp << ".";
#if defined(ANDROID) || defined(RPI)
snprintf(tmp, sizeof(tmp), "%u", a.port);

@ -48,7 +48,7 @@ namespace llarp
operator<<(std::ostream &out, const ExitInfo &xi)
{
char tmp[128] = {0};
if(inet_ntop(AF_INET6, &xi.address, tmp, sizeof(tmp)))
if(inet_ntop(AF_INET6, (void *)&xi.address, tmp, sizeof(tmp)))
out << std::string(tmp);
else
return out;

@ -250,8 +250,8 @@ namespace llarp
{
char strbuf[32] = {0};
char netbuf[32] = {0};
inet_ntop(AF_INET, &a.addr, strbuf, sizeof(strbuf));
inet_ntop(AF_INET, &a.netmask_bits, netbuf, sizeof(netbuf));
inet_ntop(AF_INET, (void*)&a.addr, strbuf, sizeof(strbuf));
inet_ntop(AF_INET, (void*)&a.netmask_bits, netbuf, sizeof(netbuf));
out << std::string(strbuf) + "/" + std::string(netbuf);
return out;
}

@ -31,21 +31,27 @@
// we already have our own definition of these
// -despair
#ifndef inet_ntop
namespace {
extern "C" {
const char* inet_ntop(int af, const void *src, char *dst, size_t size);
int inet_pton(int af, const char *src, void *dst);
}
}
namespace
{
extern "C"
{
const char *
inet_ntop(int af, const void *src, char *dst, size_t size);
int
inet_pton(int af, const char *src, void *dst);
}
} // namespace
#endif
//######################################################################
const char *libutp::inet_ntop(int af, const void *src, char *dest, size_t length)
const char *
libutp::inet_ntop(int af, const void *src, char *dest, size_t length)
{
return ::inet_ntop(af, src, dest, length);
return ::inet_ntop(af, (void *)src, dest, length);
}
//######################################################################
int libutp::inet_pton(int af, const char* src, void* dest)
int
libutp::inet_pton(int af, const char *src, void *dest)
{
return ::inet_pton(af, src, dest);
return ::inet_pton(af, src, dest);
}

File diff suppressed because it is too large Load Diff

@ -32,109 +32,135 @@
#include "libutp_inet_ntop.h"
byte PackedSockAddr::get_family() const
byte
PackedSockAddr::get_family() const
{
#if defined(__sh__)
return ((_sin6d[0] == 0) && (_sin6d[1] == 0) && (_sin6d[2] == htonl(0xffff)) != 0) ?
AF_INET : AF_INET6;
#else
return (IN6_IS_ADDR_V4MAPPED(&_in._in6addr) != 0) ? AF_INET : AF_INET6;
#endif // defined(__sh__)
#if defined(__sh__)
return ((_sin6d[0] == 0) && (_sin6d[1] == 0)
&& (_sin6d[2] == htonl(0xffff)) != 0)
? AF_INET
: AF_INET6;
#else
return (IN6_IS_ADDR_V4MAPPED(&_in._in6addr) != 0) ? AF_INET : AF_INET6;
#endif // defined(__sh__)
}
bool PackedSockAddr::operator==(const PackedSockAddr& rhs) const
bool
PackedSockAddr::operator==(const PackedSockAddr &rhs) const
{
if (&rhs == this)
return true;
if (_port != rhs._port)
return false;
return memcmp(_sin6, rhs._sin6, sizeof(_sin6)) == 0;
if(&rhs == this)
return true;
if(_port != rhs._port)
return false;
return memcmp(_sin6, rhs._sin6, sizeof(_sin6)) == 0;
}
bool PackedSockAddr::operator!=(const PackedSockAddr& rhs) const
bool
PackedSockAddr::operator!=(const PackedSockAddr &rhs) const
{
return !(*this == rhs);
return !(*this == rhs);
}
uint32 PackedSockAddr::compute_hash() const {
return utp_hash_mem(&_in, sizeof(_in)) ^ _port;
uint32
PackedSockAddr::compute_hash() const
{
return utp_hash_mem(&_in, sizeof(_in)) ^ _port;
}
void PackedSockAddr::set(const SOCKADDR_STORAGE* sa, socklen_t len)
void
PackedSockAddr::set(const SOCKADDR_STORAGE *sa, socklen_t len)
{
// on unix, the cast does nothing, socklen_t is _already_ unsigned
if (sa->ss_family == AF_INET) {
assert((unsigned)len >= sizeof(sockaddr_in));
const sockaddr_in *sin = (sockaddr_in*)sa;
_sin6w[0] = 0;
_sin6w[1] = 0;
_sin6w[2] = 0;
_sin6w[3] = 0;
_sin6w[4] = 0;
_sin6w[5] = 0xffff;
_sin4 = sin->sin_addr.s_addr;
_port = ntohs(sin->sin_port);
} else {
assert((unsigned)len >= sizeof(sockaddr_in6));
const sockaddr_in6 *sin6 = (sockaddr_in6*)sa;
_in._in6addr = sin6->sin6_addr;
_port = ntohs(sin6->sin6_port);
}
// on unix, the cast does nothing, socklen_t is _already_ unsigned
if(sa->ss_family == AF_INET)
{
assert((unsigned)len >= sizeof(sockaddr_in));
const sockaddr_in *sin = (sockaddr_in *)sa;
_sin6w[0] = 0;
_sin6w[1] = 0;
_sin6w[2] = 0;
_sin6w[3] = 0;
_sin6w[4] = 0;
_sin6w[5] = 0xffff;
_sin4 = sin->sin_addr.s_addr;
_port = ntohs(sin->sin_port);
}
else
{
assert((unsigned)len >= sizeof(sockaddr_in6));
const sockaddr_in6 *sin6 = (sockaddr_in6 *)sa;
_in._in6addr = sin6->sin6_addr;
_port = ntohs(sin6->sin6_port);
}
(void)len;
}
PackedSockAddr::PackedSockAddr(const SOCKADDR_STORAGE* sa, socklen_t len)
PackedSockAddr::PackedSockAddr(const SOCKADDR_STORAGE *sa, socklen_t len)
{
set(sa, len);
set(sa, len);
}
PackedSockAddr::PackedSockAddr(void)
{
SOCKADDR_STORAGE sa;
socklen_t len = sizeof(SOCKADDR_STORAGE);
memset(&sa, 0, len);
sa.ss_family = AF_INET;
set(&sa, len);
SOCKADDR_STORAGE sa;
socklen_t len = sizeof(SOCKADDR_STORAGE);
memset(&sa, 0, len);
sa.ss_family = AF_INET;
set(&sa, len);
}
SOCKADDR_STORAGE PackedSockAddr::get_sockaddr_storage(socklen_t *len = NULL) const
SOCKADDR_STORAGE
PackedSockAddr::get_sockaddr_storage(socklen_t *len = NULL) const
{
SOCKADDR_STORAGE sa;
const byte family = get_family();
if (family == AF_INET) {
sockaddr_in *sin = (sockaddr_in*)&sa;
if (len) *len = sizeof(sockaddr_in);
memset(sin, 0, sizeof(sockaddr_in));
sin->sin_family = family;
sin->sin_port = htons(_port);
sin->sin_addr.s_addr = _sin4;
} else {
sockaddr_in6 *sin6 = (sockaddr_in6*)&sa;
memset(sin6, 0, sizeof(sockaddr_in6));
if (len) *len = sizeof(sockaddr_in6);
sin6->sin6_family = family;
sin6->sin6_addr = _in._in6addr;
sin6->sin6_port = htons(_port);
}
return sa;
SOCKADDR_STORAGE sa;
const byte family = get_family();
if(family == AF_INET)
{
sockaddr_in *sin = (sockaddr_in *)&sa;
if(len)
*len = sizeof(sockaddr_in);
memset(sin, 0, sizeof(sockaddr_in));
sin->sin_family = family;
sin->sin_port = htons(_port);
sin->sin_addr.s_addr = _sin4;
}
else
{
sockaddr_in6 *sin6 = (sockaddr_in6 *)&sa;
memset(sin6, 0, sizeof(sockaddr_in6));
if(len)
*len = sizeof(sockaddr_in6);
sin6->sin6_family = family;
sin6->sin6_addr = _in._in6addr;
sin6->sin6_port = htons(_port);
}
return sa;
}
// #define addrfmt(x, s) x.fmt(s, sizeof(s))
cstr PackedSockAddr::fmt(str s, size_t len) const
cstr
PackedSockAddr::fmt(str s, size_t len) const
{
memset(s, 0, len);
const byte family = get_family();
str i;
if (family == AF_INET) {
INET_NTOP(family, (uint32*)&_sin4, s, len);
i = s;
while (*++i) {}
} else {
i = s;
*i++ = '[';
INET_NTOP(family, (in6_addr*)&_in._in6addr, i, len-1);
while (*++i) {}
*i++ = ']';
}
snprintf(i, len - (i-s), ":%u", _port);
return s;
memset(s, 0, len);
const byte family = get_family();
str i;
if(family == AF_INET)
{
INET_NTOP(family, (uint32 *)&_sin4, s, len);
i = s;
while(*++i)
{
}
}
else
{
i = s;
*i++ = '[';
INET_NTOP(family, (in6_addr *)&_in._in6addr, i, len - 1);
while(*++i)
{
}
*i++ = ']';
}
snprintf(i, len - (i - s), ":%u", _port);
return s;
}

@ -140,7 +140,7 @@ namespace llarp
if(!bencode_write_bytestring(buff, pubkey, PUBKEYSIZE))
return false;
/** ip */
ipstr = inet_ntop(AF_INET6, &ip, ipbuff, sizeof(ipbuff));
ipstr = inet_ntop(AF_INET6, (void *)&ip, ipbuff, sizeof(ipbuff));
if(!ipstr)
return false;
if(!bencode_write_bytestring(buff, "i", 1))

@ -5,23 +5,27 @@
void
hexDump(const char *buffer, uint16_t size)
{
char hex_buffer[size * 3 + 1];
// would rather heap allocate than use VLA
char *hex_buffer = new char[size * 3 + 1];
hex_buffer[size * 3] = 0;
for(unsigned int j = 0; j < size; j++)
sprintf(&hex_buffer[3 * j], "%02X ", buffer[j]);
std::string str(hex_buffer);
llarp::LogInfo("First ", size, " bytes: ", str);
delete[] hex_buffer;
}
void
hexDumpAt(const char *const buffer, uint32_t pos, uint16_t size)
{
char hex_buffer[size * 3 + 1];
// would rather heap allocate than use VLA
char *hex_buffer = new char[size * 3 + 1];
hex_buffer[size * 3] = 0;
for(unsigned int j = 0; j < size; j++)
sprintf(&hex_buffer[3 * j], "%02X ", buffer[pos + j]);
std::string str(hex_buffer);
llarp::LogInfo(pos, " ", size, " bytes: ", str);
delete[] hex_buffer;
}
/*

@ -8,6 +8,8 @@ extern dns_tracker dns_udp_tracker;
#define MIN wmin
#endif
constexpr size_t BUFFER_SIZE = 1500;
ssize_t
raw_sendto_dns_hook_func(void *sock, const struct sockaddr *from,
const void *buffer, size_t length)
@ -40,9 +42,8 @@ void
write404_dnss_response(const struct sockaddr *from,
dnsd_question_request *request)
{
const size_t BUFFER_SIZE = 1024 + (request->question.name.size() * 2);
char buf[BUFFER_SIZE];
memset(buf, 0, BUFFER_SIZE);
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
// build header
@ -81,9 +82,8 @@ void
writecname_dnss_response(std::string cname, const struct sockaddr *from,
dnsd_question_request *request)
{
const size_t BUFFER_SIZE = 1024 + (request->question.name.size() * 2);
char buf[BUFFER_SIZE]; // heh, another UNIX compiler extension: VLAs in C++
memset(buf, 0, BUFFER_SIZE);
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
// build header
@ -150,10 +150,10 @@ void
writesend_dnss_revresponse(std::string reverse, const struct sockaddr *from,
dnsd_question_request *request)
{
const size_t BUFFER_SIZE = 1500;
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
// build header
put16bits(write_buffer, request->id);
int fields = (1 << 15); // QR => message type, 1 = response
@ -200,9 +200,8 @@ writesend_dnss_response(llarp::huint32_t *hostRes, const struct sockaddr *from,
return;
}
const size_t BUFFER_SIZE = 1024 + (request->question.name.size() * 2);
char buf[BUFFER_SIZE];
memset(buf, 0, BUFFER_SIZE);
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
// build header
@ -259,9 +258,8 @@ writesend_dnss_mxresponse(uint16_t priority, std::string mx,
const struct sockaddr *from,
dnsd_question_request *request)
{
const size_t BUFFER_SIZE = 1024 + (request->question.name.size() * 2);
char buf[BUFFER_SIZE];
memset(buf, 0, BUFFER_SIZE);
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
// build header
@ -302,9 +300,8 @@ void
writesend_dnss_txtresponse(std::string txt, const struct sockaddr *from,
dnsd_question_request *request)
{
const size_t BUFFER_SIZE = 1024 + (request->question.name.size() * 2);
char buf[BUFFER_SIZE];
memset(buf, 0, BUFFER_SIZE);
char buf[BUFFER_SIZE] = {0};
char *write_buffer = buf;
char *bufferBegin = buf;
// build header

@ -17,14 +17,14 @@
#endif
#ifndef MAX_WRITE_QUEUE_SIZE
#define MAX_WRITE_QUEUE_SIZE 1024
#define MAX_WRITE_QUEUE_SIZE (1024UL)
#endif
#ifndef EV_READ_BUF_SZ
#define EV_READ_BUF_SZ (4 * 1024)
#define EV_READ_BUF_SZ (4 * 1024UL)
#endif
#ifndef EV_WRITE_BUF_SZ
#define EV_WRITE_BUF_SZ (2 * 1024)
#define EV_WRITE_BUF_SZ (2 * 1024UL)
#endif
namespace llarp

@ -15,7 +15,7 @@ namespace llarp
int
tcp_conn::read(void* buf, size_t sz)
{
WSABUF r_buf = {sz, (char*)buf};
WSABUF r_buf = {(u_long)sz, (char*)buf};
DWORD amount = 0;
WSARecv(std::get< SOCKET >(fd), &r_buf, 1, nullptr, 0, &portfd[0], nullptr);
@ -38,7 +38,7 @@ namespace llarp
ssize_t
tcp_conn::do_write(void* buf, size_t sz)
{
WSABUF s_buf = {sz, (char*)buf};
WSABUF s_buf = {(u_long)sz, (char*)buf};
DWORD sent = 0;
if(_shouldClose)
@ -136,7 +136,7 @@ namespace llarp
socklen_t slen = sizeof(src);
sockaddr* addr = (sockaddr*)&src;
unsigned long flags = 0;
WSABUF wbuf = {sz, static_cast< char* >(buf)};
WSABUF wbuf = {(u_long)sz, static_cast< char* >(buf)};
// WSARecvFrom
llarp::LogDebug("read ", sz, " bytes into socket");
int ret = ::WSARecvFrom(std::get< SOCKET >(fd), &wbuf, 1, nullptr, &flags,
@ -156,7 +156,7 @@ namespace llarp
sendto(const sockaddr* to, const void* data, size_t sz)
{
socklen_t slen;
WSABUF wbuf = {sz, (char*)data};
WSABUF wbuf = {(u_long)sz, (char*)data};
switch(to->sa_family)
{
case AF_INET:
@ -242,7 +242,7 @@ namespace llarp
setup()
{
llarp::LogDebug("set ifname to ", t->ifname);
strncpy(tunif->if_name, t->ifname, sizeof(tunif->if_name));
strncpy(tunif->if_name, t->ifname, IFNAMSIZ);
if(tuntap_start(tunif, TUNTAP_MODE_TUNNEL, 0) == -1)
{
@ -365,38 +365,28 @@ struct llarp_win32_loop : public llarp_ev_loop
int
tick(int ms)
{
// The only field we really care about is
// the listener_id, as it contains the address
// of the ev_io instance.
DWORD iolen = 0;
// ULONG_PTR is guaranteed to be the same size
// as an arch-specific pointer value
ULONG_PTR ev_id = 0;
WSAOVERLAPPED* qdata = nullptr;
int idx = 0;
BOOL result =
::GetQueuedCompletionStatus(iocpfd, &iolen, &ev_id, &qdata, ms);
llarp::ev_io* ev = reinterpret_cast< llarp::ev_io* >(ev_id);
if(ev && qdata)
OVERLAPPED_ENTRY events[1024];
ULONG numEvents = 0;
if(::GetQueuedCompletionStatusEx(iocpfd, events, 1024, &numEvents, ms,
false))
{
llarp::LogDebug("size: ", iolen, "\tev_id: ", ev_id, "\tqdata: ", qdata);
if(ev->write)
ev->flush_write();
else
ev->read(readbuf, iolen);
++idx;
}
if(!idx)
return -1;
else
{
result = idx;
tick_listeners();
for(ULONG idx = 0; idx < numEvents; ++idx)
{
llarp::ev_io* ev =
reinterpret_cast< llarp::ev_io* >(events[idx].lpCompletionKey);
if(ev)
{
if(ev->write)
ev->flush_write();
auto amount =
std::min(EV_READ_BUF_SZ, events[idx].dwNumberOfBytesTransferred);
memcpy(readbuf, events[idx].lpOverlapped->Pointer, amount);
ev->read(readbuf, amount);
}
}
}
return result;
tick_listeners();
return 0;
}
// ok apparently this isn't being used yet...

@ -31,12 +31,12 @@ namespace llarp
if(!bencode_start_dict(buf))
return false;
if(!inet_ntop(AF_INET6, &address, tmp, sizeof(tmp)))
if(!inet_ntop(AF_INET6, (void*)&address, tmp, sizeof(tmp)))
return false;
if(!BEncodeWriteDictString("a", std::string(tmp), buf))
return false;
if(!inet_ntop(AF_INET6, &netmask, tmp, sizeof(tmp)))
if(!inet_ntop(AF_INET6, (void*)&netmask, tmp, sizeof(tmp)))
return false;
if(!BEncodeWriteDictString("b", std::string(tmp), buf))
return false;

@ -12,13 +12,14 @@ test_sendto_dns_hook(__attribute__((unused)) void *sock,
__attribute__((unused)) const struct sockaddr *from,
const void *buffer, size_t length)
{
char hex_buffer[length * 3 + 1];
char *hex_buffer = new char[length * 3 + 1];
hex_buffer[length * 3] = 0;
for(unsigned int j = 0; j < length; j++)
sprintf(&hex_buffer[3 * j], "%02X ", ((const char *)buffer)[j]);
// printf("Got [%zu] bytes: [%s]\n", length, hex_buffer);
g_result = hex_buffer;
g_length = length;
delete[] hex_buffer;
return length;
}

Loading…
Cancel
Save