Archives
/
lokinet
mirror of https://github.com/oxen-io/lokinet
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

if we didn't specify a path to save our config in, only create .lokinet on the assumption that $HOME or $APPDATA (on NT) already exist

Browse Source 
add win32 tun glue, fix llarp timebase
(In fact, _both_ of these are guaranteed to exist on their respective platforms.)
also, tuntap is now wired up to the windows port
pull/18/head
despair86 6 years ago
parent e3a94101b4
commit 8ac7d4f6dc
12 changed files with 580 additions and 379 deletions
Show Stats Download Patch File Download Diff File

22
CMakeLists.txt
Unescape Escape View File

@ -61,6 +61,10 @@ else()
set(THREAD_LIB pthread) set(THREAD_LIB pthread)
endif() endif()
# This merely allows the Microsoft C++ compiler
# to substitute AVX opcodes for SSE or i687 opcodes
# in the reference implementation, if it chooses to
# do so in the optimisation pass.
if(MSVC) if(MSVC)
option (BUILD_AVX2 "Enable AVX2 FPU vector instructions." OFF) option (BUILD_AVX2 "Enable AVX2 FPU vector instructions." OFF)
if (BUILD_AVX2) if (BUILD_AVX2)
@ -97,7 +101,7 @@ set(OPTIMIZE_FLAGS "-O2")
set(DEBUG_FLAGS "-Od -ZI") set(DEBUG_FLAGS "-Od -ZI")
else() else()
set(OPTIMIZE_FLAGS "-O3") set(OPTIMIZE_FLAGS "-O3")
set(DEBUG_FLAGS "-O0 -g") set(DEBUG_FLAGS "-O0 -g3")
endif() endif()
if(ASAN) if(ASAN)
@ -228,11 +232,12 @@ set(LIBTUNTAP_SRC_BASE
${LIBTUNTAP_IMPL}) ${LIBTUNTAP_IMPL})
if (UNIX) if (UNIX)
set(LIBTUNTAP_SRC set(LIBTUNTAP_SRC
${TT_ROOT}/tuntap-unix.c ${TT_ROOT}/tuntap-unix.c
${LIBTUNTAP_SRC_BASE}) ${LIBTUNTAP_SRC_BASE})
endif() else()
set(LIBTUNTAP_SRC ${LIBTUNTAP_SRC_BASE})
endif(UNIX)
set(CPP_BACKPORT_SRC set(CPP_BACKPORT_SRC
vendor/cppbackport-master/lib/fs/rename.cpp vendor/cppbackport-master/lib/fs/rename.cpp
vendor/cppbackport-master/lib/fs/filestatus.cpp vendor/cppbackport-master/lib/fs/filestatus.cpp
@ -289,6 +294,14 @@ set(LIB_PLATFORM_SRC
contrib/msc/getopt1.c contrib/msc/getopt1.c
) )
# this is written _entirely_ using
# Unix compiler extensions, normally
# it should not be possible to use
# operators on vector types.
# GCC and Clang do so, and emit the proper
# opcode to perform the specified operation
# to each value in parallel.
if(NOT MSVC)
set(NTRU_AVX_SRC set(NTRU_AVX_SRC
crypto/libntrup/src/avx/randomsmall.c crypto/libntrup/src/avx/randomsmall.c
crypto/libntrup/src/avx/weight.c crypto/libntrup/src/avx/weight.c
@ -307,6 +320,7 @@ set(NTRU_AVX_SRC
crypto/libntrup/src/avx/rq.c crypto/libntrup/src/avx/rq.c
crypto/libntrup/src/avx/rq_mod3.c crypto/libntrup/src/avx/rq_mod3.c
) )
endif(NOT MSVC)
set(NTRU_REF_SRC set(NTRU_REF_SRC
crypto/libntrup/src/ref/randomsmall.c crypto/libntrup/src/ref/randomsmall.c

33
daemon/main.cpp
Unescape Escape View File

@ -4,7 +4,9 @@
#include <getopt.h> #include <getopt.h>
#include <string> #include <string>
#include <iostream> #include <iostream>
#ifndef _MSC_VER
#include <libgen.h> #include <libgen.h>
#endif
#include "fs.hpp" #include "fs.hpp"
#ifdef _WIN32 #ifdef _WIN32
@ -28,6 +30,25 @@ printHelp(const char *argv0, int code = 1)
return code; return code;
} }
#ifdef _WIN32
int
startWinsock()
{
WSADATA wsockd;
int err;
// We used to defer starting winsock until
// we got to the iocp event loop
// but getaddrinfo(3) requires that winsock be in core already
err = ::WSAStartup(MAKEWORD(2, 2), &wsockd);
if(err)
{
perror("Failed to start Windows Sockets");
return err;
}
return 0;
}
#endif
int int
main(int argc, char *argv[]) main(int argc, char *argv[])
{ {
@ -38,6 +59,11 @@ main(int argc, char *argv[])
multiThreaded = false; multiThreaded = false;
} }
#ifdef _WIN32
if(startWinsock())
return -1;
#endif
int opt = 0; int opt = 0;
bool genconfigOnly = false; bool genconfigOnly = false;
while((opt = getopt(argc, argv, "hg")) != -1) while((opt = getopt(argc, argv, "hg")) != -1)
@ -96,7 +122,9 @@ main(int argc, char *argv[])
fs::path fpath = basepath / "lokinet.ini"; fs::path fpath = basepath / "lokinet.ini";
std::error_code ec; std::error_code ec;
if(!fs::create_directories(basepath, ec)) // These paths are guaranteed to exist - $APPDATA or $HOME
// so only create .lokinet/*
if(!fs::create_directory(basepath, ec))
{ {
if(ec) if(ec)
{ {
@ -127,5 +155,8 @@ main(int argc, char *argv[])
llarp_main_free(ctx); llarp_main_free(ctx);
} }
exit(code); exit(code);
#ifdef _WIN32
::WSACleanup();
#endif
return code; return code;
} }

4
include/llarp/net.hpp
Unescape Escape View File

@ -439,7 +439,7 @@ namespace llarp
isOneSevenPrivate(uint32_t byte) isOneSevenPrivate(uint32_t byte)
{ {
uint8_t byte1 = byte >> 24 & 0xff; uint8_t byte1 = byte >> 24 & 0xff;
uint8_t byte2 = (0x00ff0000 & byte >> 16); uint8_t byte2 = (0x00ff0000 & byte) >> 16;
return byte1 == 172 && (byte2 >= 16 || byte2 <= 31); return byte1 == 172 && (byte2 >= 16 || byte2 <= 31);
} }
@ -447,7 +447,7 @@ namespace llarp
isOneNinePrivate(uint32_t byte) isOneNinePrivate(uint32_t byte)
{ {
uint8_t byte1 = byte >> 24 & 0xff; uint8_t byte1 = byte >> 24 & 0xff;
uint8_t byte2 = (0x00ff0000 & byte >> 16); uint8_t byte2 = (0x00ff0000 & byte) >> 16;
return byte1 == 192 && byte2 == 168; return byte1 == 192 && byte2 == 168;
} }

1
include/llarp/service/IntroSet.hpp
Unescape Escape View File

@ -10,6 +10,7 @@
#include <llarp/service/tag.hpp> #include <llarp/service/tag.hpp>
#include <vector> #include <vector>
#include <algorithm>
namespace llarp namespace llarp
{ {

8
include/tuntap.h
Unescape Escape View File

@ -92,7 +92,7 @@ typedef struct in6_addr t_tun_in6_addr;
* Windows helpers * Windows helpers
*/ */
#if defined Windows #if defined Windows
#define strncat(x, y, z) strncat_s((x), _countof(x), (y), (z)); //#define strncat(x, y, z) strncat_s((x), _countof(x), (y), (z));
#define strdup(x) _strdup(x) #define strdup(x) _strdup(x)
#endif #endif
@ -119,10 +119,12 @@ typedef struct in6_addr t_tun_in6_addr;
/* Handle Windows symbols export */ /* Handle Windows symbols export */
#if defined Windows #if defined Windows
#if defined(tuntap_EXPORTS) /* CMake generated goo */ #if defined(tuntap_EXPORTS) && defined(_USRDLL) /* CMake generated goo */
#define TUNTAP_EXPORT __declspec(dllexport) #define TUNTAP_EXPORT __declspec(dllexport)
#else #elif defined(tuntap_EXPORTS)
#define TUNTAP_EXPORT __declspec(dllimport) #define TUNTAP_EXPORT __declspec(dllimport)
#else
#define TUNTAP_EXPORT extern
#endif #endif
#else /* Unix */ #else /* Unix */
#define TUNTAP_EXPORT extern #define TUNTAP_EXPORT extern

4
llarp/config.cpp
Unescape Escape View File

@ -102,7 +102,11 @@ extern "C"
if(basedir) if(basedir)
{ {
basepath = basedir; basepath = basedir;
#ifndef _WIN32
basepath += "/"; basepath += "/";
#else
basepath += "\\";
#endif
} }
std::ofstream f(fname); std::ofstream f(fname);

160
llarp/ev.hpp
Unescape Escape View File

@ -45,94 +45,100 @@ namespace llarp
virtual bool virtual bool
do_write(void* data, size_t sz) do_write(void* data, size_t sz)
{ {
return write(fd, data, sz) != -1;
}
/// called in event loop when fd is ready for writing
/// requeues anything not written
/// this assumes fd is set to non blocking
virtual void
flush_write()
{
m_writeq.Process([&](WriteBuffer& buffer) {
// todo: wtf???
#ifndef _WIN32 #ifndef _WIN32
do_write(buffer.buf, buffer.bufsz); return write(fd, data, sz) != -1;
// if we would block we save the entries for later
// discard entry
#else #else
// writefile return WriteFile((void*)fd, data, sz, nullptr, nullptr);
#endif
}
/// called in event loop when fd is ready for writing
/// requeues anything not written
/// this assumes fd is set to non blocking
virtual void
flush_write()
{
m_writeq.Process([&](WriteBuffer& buffer) {
// todo: wtf???
#ifndef _WIN32
do_write(buffer.buf, buffer.bufsz);
// if we would block we save the entries for later
// discard entry
#else
WriteFile((void*)fd, buffer.buf, buffer.bufsz, nullptr, nullptr);
#endif
});
/// reset errno
errno = 0;
#if _WIN32
SetLastError(0);
#endif #endif
}); }
/// reset errno
errno = 0; struct WriteBuffer
{
llarp_time_t timestamp = 0;
size_t bufsz;
byte_t buf[1500];
WriteBuffer() = default;
WriteBuffer(const void* ptr, size_t sz)
{
if(sz <= sizeof(buf))
{
bufsz = sz;
memcpy(buf, ptr, bufsz);
} }
else
bufsz = 0;
}
struct WriteBuffer struct GetTime
{
llarp_time_t
operator()(const WriteBuffer& w) const
{ {
llarp_time_t timestamp = 0; return w.timestamp;
size_t bufsz; }
byte_t buf[1500]; };
WriteBuffer() = default; struct PutTime
{
WriteBuffer(const void* ptr, size_t sz) void
{ operator()(WriteBuffer& w) const
if(sz <= sizeof(buf))
{
bufsz = sz;
memcpy(buf, ptr, bufsz);
}
else
bufsz = 0;
}
struct GetTime
{
llarp_time_t
operator()(const WriteBuffer& w) const
{
return w.timestamp;
}
};
struct PutTime
{
void
operator()(WriteBuffer& w) const
{
w.timestamp = llarp_time_now_ms();
}
};
struct Compare
{
bool
operator()(const WriteBuffer& left, const WriteBuffer& right) const
{
return left.timestamp < right.timestamp;
}
};
};
llarp::util::CoDelQueue< WriteBuffer, WriteBuffer::GetTime,
WriteBuffer::PutTime, WriteBuffer::Compare,
llarp::util::NullMutex, llarp::util::NullLock >
m_writeq;
virtual ~ev_io()
{ {
w.timestamp = llarp_time_now_ms();
}
};
struct Compare
{
bool
operator()(const WriteBuffer& left, const WriteBuffer& right) const
{
return left.timestamp < right.timestamp;
}
};
};
llarp::util::CoDelQueue< WriteBuffer, WriteBuffer::GetTime,
WriteBuffer::PutTime, WriteBuffer::Compare,
llarp::util::NullMutex, llarp::util::NullLock >
m_writeq;
virtual ~ev_io()
{
#ifndef _WIN32 #ifndef _WIN32
::close(fd); ::close(fd);
#else #else
closesocket(fd); closesocket(fd);
#endif #endif
}; };
}; }
;
}; // namespace llarp }
; // namespace llarp
struct llarp_ev_loop struct llarp_ev_loop
{ {

91
llarp/ev_win32.hpp
Unescape Escape View File

@ -85,6 +85,81 @@ namespace llarp
return 0; return 0;
} }
}; };
struct tun : public ev_io
{
llarp_tun_io* t;
device* tunif;
tun(llarp_tun_io* tio)
: ev_io(-1)
, t(tio)
, tunif(tuntap_init())
{
};
int
sendto(const sockaddr* to, const void* data, size_t sz)
{
return -1;
}
void
flush_write()
{
if(t->before_write)
{
t->before_write(t);
}
ev_io::flush_write();
}
int
read(void* buf, size_t sz)
{
ssize_t ret = tuntap_read(tunif, buf, sz);
if(ret > 0 && t->recvpkt)
{
t->recvpkt(t, buf, ret);
}
return ret;
}
bool
setup()
{
llarp::LogDebug("set ifname to ", t->ifname);
strncpy(tunif->if_name, t->ifname, sizeof(tunif->if_name));
if(tuntap_start(tunif, TUNTAP_MODE_TUNNEL, 0) == -1)
{
llarp::LogWarn("failed to start interface");
return false;
}
if(tuntap_up(tunif) == -1)
{
llarp::LogWarn("failed to put interface up: ", strerror(errno));
return false;
}
if(tuntap_set_ip(tunif, t->ifaddr, t->ifaddr, t->netmask) == -1)
{
llarp::LogWarn("failed to set ip");
return false;
}
fd = (SOCKET)tunif->tun_fd;
if(fd == -1)
return false;
// set non blocking
int on = 1;
return ioctlsocket(fd, FIONBIO, (u_long*)&on) != -1;
}
~tun()
{
}
};
}; // namespace llarp }; // namespace llarp
struct llarp_win32_loop : public llarp_ev_loop struct llarp_win32_loop : public llarp_ev_loop
@ -93,22 +168,13 @@ struct llarp_win32_loop : public llarp_ev_loop
llarp_win32_loop() : iocpfd(INVALID_HANDLE_VALUE) llarp_win32_loop() : iocpfd(INVALID_HANDLE_VALUE)
{ {
WSADATA wsockd;
int err;
// So, what I was told last time was that we can defer
// loading winsock2 up to this point, as we reach this ctor
// early on during daemon startup.
err = ::WSAStartup(MAKEWORD(2, 2), &wsockd);
if(err)
perror("Failed to start Windows Sockets");
} }
~llarp_win32_loop() ~llarp_win32_loop()
{ {
if(iocpfd != INVALID_HANDLE_VALUE) if(iocpfd != INVALID_HANDLE_VALUE)
::CloseHandle(iocpfd); ::CloseHandle(iocpfd);
::WSACleanup();
} }
bool bool
@ -287,7 +353,10 @@ struct llarp_win32_loop : public llarp_ev_loop
llarp::ev_io* llarp::ev_io*
create_tun(llarp_tun_io* tun) create_tun(llarp_tun_io* tun)
{ {
// TODO implement me llarp::tun* t = new llarp::tun(tun);
if(t->setup())
return t;
delete t;
return nullptr; return nullptr;
} }

2
llarp/nodedb.cpp
Unescape Escape View File

@ -313,7 +313,7 @@ llarp_nodedb_ensure_dir(const char *dir)
std::error_code ec; std::error_code ec;
if(!fs::exists(dir, ec)) if(!fs::exists(dir, ec))
fs::create_directories(path, ec); fs::create_directory(path, ec);
if(ec) if(ec)
return false; return false;

28
llarp/time.cpp
Unescape Escape View File

@ -1,28 +1,22 @@
#include <llarp/time.h> #include <llarp/time.h>
#include <chrono> #include <sys/time.h>
namespace llarp
{
typedef std::chrono::system_clock clock_t;
template < typename Res, typename IntType >
static IntType
time_since_epoch()
{
return std::chrono::duration_cast< Res >(
llarp::clock_t::now().time_since_epoch())
.count();
}
} // namespace llarp
// these _should_ be 32-bit safe...
llarp_time_t llarp_time_t
llarp_time_now_ms() llarp_time_now_ms()
{ {
return llarp::time_since_epoch< std::chrono::milliseconds, llarp_time_t >(); struct timeval tv;
gettimeofday(&tv, nullptr);
llarp_time_t timeNow =
(llarp_time_t)(tv.tv_sec) * 1000 + (llarp_time_t)(tv.tv_usec) / 1000;
return timeNow;
} }
llarp_seconds_t llarp_seconds_t
llarp_time_now_sec() llarp_time_now_sec()
{ {
return llarp::time_since_epoch< std::chrono::seconds, llarp_seconds_t >(); struct timeval tv;
gettimeofday(&tv, nullptr);
llarp_time_t timeNow = tv.tv_sec;
return timeNow;
} }

600
vendor/libtuntap-master/tuntap-windows.c vendored
Unescape Escape View File

@ -22,352 +22,426 @@
#include <string.h> #include <string.h>
#include <time.h> #include <time.h>
#include <strsafe.h> #include <strsafe.h>
#include "tuntap.h" #include "tuntap.h"
// DDK macros
#define CTL_CODE(DeviceType, Function, Method, Access) \
(((DeviceType) << 16) | ((Access) << 14) | ((Function) << 2) | (Method))
#define FILE_DEVICE_UNKNOWN 0x00000022
#define FILE_ANY_ACCESS 0x00000000
#define METHOD_BUFFERED 0
/* From OpenVPN tap driver, common.h */ /* From OpenVPN tap driver, common.h */
#define TAP_CONTROL_CODE(request,method) CTL_CODE(FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS) #define TAP_CONTROL_CODE(request, method) \
#define TAP_IOCTL_GET_MAC TAP_CONTROL_CODE (1, METHOD_BUFFERED) CTL_CODE(FILE_DEVICE_UNKNOWN, request, method, FILE_ANY_ACCESS)
#define TAP_IOCTL_GET_VERSION TAP_CONTROL_CODE (2, METHOD_BUFFERED) #define TAP_IOCTL_GET_MAC TAP_CONTROL_CODE(1, METHOD_BUFFERED)
#define TAP_IOCTL_GET_MTU TAP_CONTROL_CODE (3, METHOD_BUFFERED) #define TAP_IOCTL_GET_VERSION TAP_CONTROL_CODE(2, METHOD_BUFFERED)
#define TAP_IOCTL_GET_INFO TAP_CONTROL_CODE (4, METHOD_BUFFERED) #define TAP_IOCTL_GET_MTU TAP_CONTROL_CODE(3, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE (5, METHOD_BUFFERED) #define TAP_IOCTL_GET_INFO TAP_CONTROL_CODE(4, METHOD_BUFFERED)
#define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE (6, METHOD_BUFFERED) #define TAP_IOCTL_CONFIG_POINT_TO_POINT TAP_CONTROL_CODE(5, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_DHCP_MASQ TAP_CONTROL_CODE (7, METHOD_BUFFERED) #define TAP_IOCTL_SET_MEDIA_STATUS TAP_CONTROL_CODE(6, METHOD_BUFFERED)
#define TAP_IOCTL_GET_LOG_LINE TAP_CONTROL_CODE (8, METHOD_BUFFERED) #define TAP_IOCTL_CONFIG_DHCP_MASQ TAP_CONTROL_CODE(7, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_DHCP_SET_OPT TAP_CONTROL_CODE (9, METHOD_BUFFERED) #define TAP_IOCTL_GET_LOG_LINE TAP_CONTROL_CODE(8, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_TUN TAP_CONTROL_CODE (10, METHOD_BUFFERED) #define TAP_IOCTL_CONFIG_DHCP_SET_OPT TAP_CONTROL_CODE(9, METHOD_BUFFERED)
#define TAP_IOCTL_CONFIG_TUN TAP_CONTROL_CODE(10, METHOD_BUFFERED)
/* Windows registry crap */ /* Windows registry crap */
#define MAX_KEY_LENGTH 255 #define MAX_KEY_LENGTH 255
#define MAX_VALUE_NAME 16383 #define MAX_VALUE_NAME 16383
#define NETWORK_ADAPTERS "SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-08002BE10318}" #define NETWORK_ADAPTERS \
"SYSTEM\\CurrentControlSet\\Control\\Class\\{4D36E972-E325-11CE-BFC1-" \
"08002BE10318}"
#define ETHER_ADDR_LEN 6
/* From OpenVPN tap driver, proto.h */ /* From OpenVPN tap driver, proto.h */
typedef unsigned long IPADDR; typedef unsigned long IPADDR;
/* This one is from Fabien Pichot, in the tNETacle source code */ /* This one is from Fabien Pichot, in the tNETacle source code */
static LPWSTR static LPWSTR
formated_error(LPWSTR pMessage, DWORD m, ...) { formated_error(LPWSTR pMessage, DWORD m, ...)
LPWSTR pBuffer = NULL; {
LPWSTR pBuffer = NULL;
va_list args = NULL; va_list args = NULL;
va_start(args, pMessage); va_start(args, pMessage);
FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER,
FORMAT_MESSAGE_ALLOCATE_BUFFER, pMessage, m, 0, (LPSTR)&pBuffer, 0, &args);
pMessage,
m,
0,
(LPSTR)&pBuffer,
0,
&args);
va_end(args); va_end(args);
return pBuffer; return pBuffer;
} }
/* TODO: Rework to be more generic and allow arbitrary key modification (MTU and stuff) */ /* TODO: Rework to be more generic and allow arbitrary key modification (MTU and
* stuff) */
static char * static char *
reg_query(char *key_name) { reg_query(char *key_name)
HKEY adapters, adapter; {
DWORD i, ret, len; HKEY adapters, adapter;
char *deviceid = NULL; DWORD i, ret, len;
DWORD sub_keys = 0; char *deviceid = NULL;
DWORD sub_keys = 0;
ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(key_name), 0, KEY_READ, &adapters);
if (ret != ERROR_SUCCESS) { ret =
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", ret)); RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(key_name), 0, KEY_READ, &adapters);
return NULL; if(ret != ERROR_SUCCESS)
} {
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", ret));
ret = RegQueryInfoKey(adapters, NULL, NULL, NULL, &sub_keys, NULL, NULL, NULL, NULL, NULL, NULL, NULL); return NULL;
if (ret != ERROR_SUCCESS) { }
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", ret));
return NULL; ret = RegQueryInfoKey(adapters, NULL, NULL, NULL, &sub_keys, NULL, NULL, NULL,
} NULL, NULL, NULL, NULL);
if(ret != ERROR_SUCCESS)
if (sub_keys <= 0) { {
tuntap_log(TUNTAP_LOG_DEBUG, "Wrong registry key"); tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", ret));
return NULL; return NULL;
} }
/* Walk througt all adapters */ if(sub_keys <= 0)
for (i = 0; i < sub_keys; i++) { {
char new_key[MAX_KEY_LENGTH]; tuntap_log(TUNTAP_LOG_DEBUG, "Wrong registry key");
char data[256]; return NULL;
TCHAR key[MAX_KEY_LENGTH]; }
DWORD keylen = MAX_KEY_LENGTH;
/* Walk througt all adapters */
/* Get the adapter key name */ for(i = 0; i < sub_keys; i++)
ret = RegEnumKeyEx(adapters, i, key, &keylen, NULL, NULL, NULL, NULL); {
if (ret != ERROR_SUCCESS) { char new_key[MAX_KEY_LENGTH];
continue; char data[256];
} TCHAR key[MAX_KEY_LENGTH];
DWORD keylen = MAX_KEY_LENGTH;
/* Append it to NETWORK_ADAPTERS and open it */
snprintf(new_key, sizeof new_key, "%s\\%s", key_name, key); /* Get the adapter key name */
ret = RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(new_key), 0, KEY_READ, &adapter); ret = RegEnumKeyEx(adapters, i, key, &keylen, NULL, NULL, NULL, NULL);
if (ret != ERROR_SUCCESS) { if(ret != ERROR_SUCCESS)
continue; {
} continue;
}
/* Check its values */
len = sizeof data; /* Append it to NETWORK_ADAPTERS and open it */
ret = RegQueryValueEx(adapter, "ComponentId", NULL, NULL, (LPBYTE)data, &len); snprintf(new_key, sizeof new_key, "%s\\%s", key_name, key);
if (ret != ERROR_SUCCESS) { ret =
/* This value doesn't exist in this adaptater tree */ RegOpenKeyEx(HKEY_LOCAL_MACHINE, TEXT(new_key), 0, KEY_READ, &adapter);
goto clean; if(ret != ERROR_SUCCESS)
} {
/* If its a tap adapter, its all good */ continue;
if (strncmp(data, "tap", 3) == 0) { }
DWORD type;
/* Check its values */
len = sizeof data; len = sizeof data;
ret = RegQueryValueEx(adapter, "NetCfgInstanceId", NULL, &type, (LPBYTE)data, &len); ret =
if (ret != ERROR_SUCCESS) { RegQueryValueEx(adapter, "ComponentId", NULL, NULL, (LPBYTE)data, &len);
tuntap_log(TUNTAP_LOG_INFO, (const char *)formated_error(L"%1", ret)); if(ret != ERROR_SUCCESS)
goto clean; {
} /* This value doesn't exist in this adaptater tree */
deviceid = strdup(data); goto clean;
break; }
} /* If its a tap adapter, its all good */
clean: if(strncmp(data, "tap", 3) == 0)
RegCloseKey(adapter); {
} DWORD type;
RegCloseKey(adapters);
return deviceid; len = sizeof data;
ret = RegQueryValueEx(adapter, "NetCfgInstanceId", NULL, &type,
(LPBYTE)data, &len);
if(ret != ERROR_SUCCESS)
{
tuntap_log(TUNTAP_LOG_INFO, (const char *)formated_error(L"%1", ret));
goto clean;
}
deviceid = strdup(data);
break;
}
clean:
RegCloseKey(adapter);
}
RegCloseKey(adapters);
return deviceid;
} }
void void
tuntap_sys_destroy(struct device *dev) { tuntap_sys_destroy(struct device *dev)
(void)dev; {
return; (void)dev;
return;
} }
int int
tuntap_start(struct device *dev, int mode, int tun) { tuntap_start(struct device *dev, int mode, int tun)
HANDLE tun_fd; {
char *deviceid; HANDLE tun_fd;
char buf[60]; char *deviceid;
char buf[60];
/* Don't re-initialise a previously started device */
if (dev->tun_fd != TUNFD_INVALID_VALUE) { /* Don't re-initialise a previously started device */
return -1; if(dev->tun_fd != TUNFD_INVALID_VALUE)
} {
return -1;
/* Shift the persistence bit */ }
if (mode & TUNTAP_MODE_PERSIST) {
mode &= ~TUNTAP_MODE_PERSIST; /* Shift the persistence bit */
} if(mode & TUNTAP_MODE_PERSIST)
{
if (mode == TUNTAP_MODE_TUNNEL) { mode &= ~TUNTAP_MODE_PERSIST;
tuntap_log(TUNTAP_LOG_NOTICE, "Layer 3 tunneling is not implemented"); }
return -1;
} if(mode == TUNTAP_MODE_TUNNEL)
else if (mode != TUNTAP_MODE_ETHERNET) { {
tuntap_log(TUNTAP_LOG_ERR, "Invalid parameter 'mode'"); tuntap_log(TUNTAP_LOG_NOTICE, "Layer 3 tunneling is not implemented");
return -1; return -1;
} }
else if(mode != TUNTAP_MODE_ETHERNET)
deviceid = reg_query(NETWORK_ADAPTERS); {
snprintf(buf, sizeof buf, "\\\\.\\Global\\%s.tap", deviceid); tuntap_log(TUNTAP_LOG_ERR, "Invalid parameter 'mode'");
tun_fd = CreateFile(buf, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING, FILE_ATTRIBUTE_SYSTEM|FILE_FLAG_OVERLAPPED, 0); return -1;
if (tun_fd == TUNFD_INVALID_VALUE) { }
int errcode = GetLastError();
deviceid = reg_query(NETWORK_ADAPTERS);
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); snprintf(buf, sizeof buf, "\\\\.\\Global\\%s.tap", deviceid);
return -1; tun_fd = CreateFile(buf, GENERIC_WRITE | GENERIC_READ, 0, 0, OPEN_EXISTING,
} FILE_ATTRIBUTE_SYSTEM | FILE_FLAG_OVERLAPPED, 0);
if(tun_fd == TUNFD_INVALID_VALUE)
dev->tun_fd = tun_fd; {
return 0; int errcode = GetLastError();
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
return -1;
}
dev->tun_fd = tun_fd;
return 0;
} }
void void
tuntap_release(struct device *dev) { tuntap_release(struct device *dev)
(void)CloseHandle(dev->tun_fd); {
free(dev); (void)CloseHandle(dev->tun_fd);
free(dev);
} }
char * char *
tuntap_get_hwaddr(struct device *dev) { tuntap_get_hwaddr(struct device *dev)
static unsigned char hwaddr[ETHER_ADDR_LEN]; {
DWORD len; static unsigned char hwaddr[ETHER_ADDR_LEN];
DWORD len;
if (DeviceIoControl(dev->tun_fd, TAP_IOCTL_GET_MAC, &hwaddr, sizeof(hwaddr), &hwaddr, sizeof(hwaddr), &len, NULL) == 0) {
int errcode = GetLastError(); if(DeviceIoControl(dev->tun_fd, TAP_IOCTL_GET_MAC, &hwaddr, sizeof(hwaddr),
&hwaddr, sizeof(hwaddr), &len, NULL)
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); == 0)
return NULL; {
} else { int errcode = GetLastError();
char buf[128];
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
(void)_snprintf_s(buf, sizeof buf, sizeof buf, "MAC address: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x", return NULL;
hwaddr[0],hwaddr[1],hwaddr[2],hwaddr[3],hwaddr[4],hwaddr[5]); }
tuntap_log(TUNTAP_LOG_DEBUG, buf); else
} {
return (char *)hwaddr; char buf[128];
(void)_snprintf_s(buf, sizeof buf, sizeof buf,
"MAC address: %.2x:%.2x:%.2x:%.2x:%.2x:%.2x", hwaddr[0],
hwaddr[1], hwaddr[2], hwaddr[3], hwaddr[4], hwaddr[5]);
tuntap_log(TUNTAP_LOG_DEBUG, buf);
}
return (char *)hwaddr;
} }
int int
tuntap_set_hwaddr(struct device *dev, const char *hwaddr) { tuntap_set_hwaddr(struct device *dev, const char *hwaddr)
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_set_hwaddr()"); {
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_set_hwaddr()");
return -1;
} }
static int static int
tuntap_sys_set_updown(struct device *dev, ULONG flag) { tuntap_sys_set_updown(struct device *dev, ULONG flag)
DWORD len; {
DWORD len;
if (DeviceIoControl(dev->tun_fd, TAP_IOCTL_SET_MEDIA_STATUS, &flag, sizeof(flag), &flag, sizeof(flag), &len, NULL) == 0) {
int errcode = GetLastError(); if(DeviceIoControl(dev->tun_fd, TAP_IOCTL_SET_MEDIA_STATUS, &flag,
sizeof(flag), &flag, sizeof(flag), &len, NULL)
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); == 0)
return -1; {
} else { int errcode = GetLastError();
char buf[32];
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
(void)_snprintf_s(buf, sizeof buf, sizeof buf, "Status: %s", flag ? "Up" : "Down"); return -1;
tuntap_log(TUNTAP_LOG_DEBUG, buf); }
return 0; else
} {
char buf[32];
(void)_snprintf_s(buf, sizeof buf, sizeof buf, "Status: %s",
flag ? "Up" : "Down");
tuntap_log(TUNTAP_LOG_DEBUG, buf);
return 0;
}
} }
int int
tuntap_up(struct device *dev) { tuntap_up(struct device *dev)
ULONG flag; {
ULONG flag;
flag = 1; flag = 1;
return tuntap_sys_set_updown(dev, flag); return tuntap_sys_set_updown(dev, flag);
} }
int int
tuntap_down(struct device *dev) { tuntap_down(struct device *dev)
ULONG flag; {
ULONG flag;
flag = 0; flag = 0;
return tuntap_sys_set_updown(dev, flag); return tuntap_sys_set_updown(dev, flag);
} }
int int
tuntap_get_mtu(struct device *dev) { tuntap_get_mtu(struct device *dev)
ULONG mtu; {
DWORD len; ULONG mtu;
DWORD len;
if (DeviceIoControl(dev->tun_fd, TAP_IOCTL_GET_MTU, &mtu, sizeof(mtu), &mtu, sizeof(mtu), &len, NULL) == 0) {
int errcode = GetLastError(); if(DeviceIoControl(dev->tun_fd, TAP_IOCTL_GET_MTU, &mtu, sizeof(mtu), &mtu,
sizeof(mtu), &len, NULL)
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); == 0)
return -1; {
} int errcode = GetLastError();
return 0;
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
return -1;
}
return 0;
} }
int int
tuntap_set_mtu(struct device *dev, int mtu) { tuntap_set_mtu(struct device *dev, int mtu)
(void)dev; {
(void)mtu; (void)dev;
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_set_mtu()"); (void)mtu;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_set_mtu()");
return -1;
} }
int int
tuntap_sys_set_ipv4(struct device *dev, t_tun_in_addr *s, uint32_t mask) { tuntap_sys_set_ipv4(struct device *dev, t_tun_in_addr *s, uint32_t mask)
IPADDR psock[4]; {
DWORD len; IPADDR psock[4];
DWORD len;
/* Address + Netmask */
psock[0] = s->S_un.S_addr; /* Address + Netmask */
psock[1] = mask; psock[0] = s->S_un.S_addr;
/* DHCP server address (We don't want it) */ psock[1] = mask;
psock[2] = 0; /* DHCP server address (We don't want it) */
/* DHCP lease time */ psock[2] = 0;
psock[3] = 0; /* DHCP lease time */
psock[3] = 0;
if (DeviceIoControl(dev->tun_fd, TAP_IOCTL_CONFIG_DHCP_MASQ, &psock, sizeof(psock), &psock, sizeof(psock), &len, NULL) == 0) {
int errcode = GetLastError(); if(DeviceIoControl(dev->tun_fd, TAP_IOCTL_CONFIG_DHCP_MASQ, &psock,
sizeof(psock), &psock, sizeof(psock), &len, NULL)
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); == 0)
return -1; {
} int errcode = GetLastError();
return 0;
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
return -1;
}
return 0;
} }
int int
tuntap_sys_set_ipv6(struct device *dev, t_tun_in6_addr *s, uint32_t mask) { tuntap_sys_set_ipv6(struct device *dev, t_tun_in6_addr *s, uint32_t mask)
(void)dev; {
(void)s; (void)dev;
(void)mask; (void)s;
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_sys_set_ipv6()"); (void)mask;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_sys_set_ipv6()");
return -1;
} }
int int
tuntap_read(struct device *dev, void *buf, size_t size) { tuntap_read(struct device *dev, void *buf, size_t size)
DWORD len; {
DWORD len;
if (ReadFile(dev->tun_fd, buf, (DWORD)size, &len, NULL) == 0) { if(ReadFile(dev->tun_fd, buf, (DWORD)size, &len, NULL) == 0)
int errcode = GetLastError(); {
int errcode = GetLastError();
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
return -1; return -1;
} }
return 0; return 0;
} }
int int
tuntap_write(struct device *dev, void *buf, size_t size) { tuntap_write(struct device *dev, void *buf, size_t size)
DWORD len; {
DWORD len;
if (WriteFile(dev->tun_fd, buf, (DWORD)size, &len, NULL) == 0) { if(WriteFile(dev->tun_fd, buf, (DWORD)size, &len, NULL) == 0)
int errcode = GetLastError(); {
int errcode = GetLastError();
tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode)); tuntap_log(TUNTAP_LOG_ERR, (const char *)formated_error(L"%1%0", errcode));
return -1; return -1;
} }
return 0; return 0;
} }
int int
tuntap_get_readable(struct device *dev) { tuntap_get_readable(struct device *dev)
(void)dev; {
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_get_readable()"); (void)dev;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_get_readable()");
return -1;
} }
int int
tuntap_set_nonblocking(struct device *dev, int set) { tuntap_set_nonblocking(struct device *dev, int set)
(void)dev; {
(void)set; (void)dev;
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_set_nonblocking()"); (void)set;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_set_nonblocking()");
return -1;
} }
int int
tuntap_set_debug(struct device *dev, int set) { tuntap_set_debug(struct device *dev, int set)
(void)dev; {
(void)set; (void)dev;
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_set_debug()"); (void)set;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_set_debug()");
return -1;
} }
int int
tuntap_set_descr(struct device *dev, const char *descr) { tuntap_set_descr(struct device *dev, const char *descr)
(void)dev; {
(void)descr; (void)dev;
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_set_descr()"); (void)descr;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_set_descr()");
return -1;
} }
int int
tuntap_set_ifname(struct device *dev, const char *name) { tuntap_set_ifname(struct device *dev, const char *name)
/* TODO: Check Windows API to know how to rename an interface */ {
(void)dev; /* TODO: Check Windows API to know how to rename an interface */
(void)name; (void)dev;
tuntap_log(TUNTAP_LOG_NOTICE, "Your system does not support tuntap_set_ifname()"); (void)name;
return -1; tuntap_log(TUNTAP_LOG_NOTICE,
"Your system does not support tuntap_set_ifname()");
return -1;
} }

6
vendor/libtuntap-master/tuntap.cpp vendored
Unescape Escape View File

@ -31,6 +31,12 @@
#include <winsock2.h> #include <winsock2.h>
#include <ws2tcpip.h> #include <ws2tcpip.h>
#include <wspiapi.h> #include <wspiapi.h>
#ifndef _MSC_VER
extern "C" int
inet_pton(int af, const char *src, void *dst);
extern "C" const char *
inet_ntop(int af, const void *src, char *dst, size_t size);
#endif
#else #else
#include <arpa/inet.h> #include <arpa/inet.h>
#include <netinet/in.h> #include <netinet/in.h>

Write Preview
Loading…
Cancel
Save