/* vim: set expandtab ts=4 sw=4: */
/*
* You may redistribute this program and/or modify it under the terms of
* the GNU General Public License as published by the Free Software Foundation,
* either version 3 of the License, or (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see .
*/
#define _WIN32_WINNT 0x0600
#include "exception/WinEr.h"
#include "util/platform/netdev/NetPlatform.h"
#include "util/Bits.h"
#include "util/platform/Sockaddr.h"
#include
#include
#define NET_LUID misalligned_NET_LUID
#define PNET_LUID misalligned_PNET_LUID
#define IF_LUID misalligned_IF_LUID
#define PIF_LUID misalligned_PIF_LUID
#include
#undef NET_LUID
#undef PNET_LUID
#undef IF_LUID
#undef PIF_LUID
// mingw-w64 incorrectly pragma pack's this to 1 byte.
typedef union NET_LUID {
ULONG64 Value;
__C89_NAMELESS struct { /* bitfield with 64 bit types. */
ULONG64 Reserved :24;
ULONG64 NetLuidIndex :24;
ULONG64 IfType :16;
} Info;
} NET_LUID, *PNET_LUID;
Assert_compileTime(sizeof(NET_LUID) == 8);
typedef NET_LUID IF_LUID, *PIF_LUID;
#include
#include
#include
#include
#include
#include
#include
#include
static Err_DEFUN getLuid(NET_LUID* out, const char* name, struct Allocator* alloc))
{
uint16_t ifName[IF_MAX_STRING_SIZE + 1] = {0};
WinEr_check(alloc,
(!MultiByteToWideChar(CP_ACP, 0, name, strlen(name), ifName, IF_MAX_STRING_SIZE + 1))
);
WinEr_check(alloc, ConvertInterfaceAliasToLuid(ifName, &out));
return NULL;
}
static LONG flushAddresses(NET_LUID luid, MIB_UNICASTIPADDRESS_TABLE* table)
{
LONG out = NO_ERROR;
for (int i = 0; i < (int)table->NumEntries; i++) {
if (table->Table[i].InterfaceLuid.Value == luid.Value) {
if ((out = DeleteUnicastIpAddressEntry(&table->Table[i]))) {
return out;
}
}
}
return out;
}
Err_DEFUN NetPlatform_flushAddresses(const char* deviceName, struct Allocator* alloc)
{
NET_LUID luid = -1;
Err(getLuid(&luid, deviceName, alloc));
MIB_UNICASTIPADDRESS_TABLE* table;
WinEr_check(alloc, GetUnicastIpAddressTable(AF_INET, &table));
LONG ret = flushAddresses(luid, table);
FreeMibTable(table);
if (ret) {
WinEr_fail(alloc, "DeleteUnicastIpAddressEntry(&table->Table[i])", ret);
}
WinEr_check(alloc, GetUnicastIpAddressTable(AF_INET6, &table));
ret = flushAddresses(luid, table);
FreeMibTable(table);
if (ret) {
WinEr_fail(alloc, "DeleteUnicastIpAddressEntry(&table->Table[i])", ret);
}
return NULL;
}
#include "util/Hex.h"
#include
static Err_DEFUN setupRoute(const char* deviceName,
const uint8_t* addrBytes,
int prefixLen,
int addrFam,
struct Allocator* alloc)
{
void WINAPI InitializeIpForwardEntry(PMIB_IPFORWARD_ROW2 Row);
MIB_IPFORWARD_ROW2 row = {
.InterfaceLuid = 0,
.ValidLifetime = WSA_INFINITE,
.PreferredLifetime = WSA_INFINITE,
.Metric = 0xffffffff,
.Protocol = MIB_IPPROTO_NETMGMT,
.SitePrefixLength = 255,
.DestinationPrefix = {
.PrefixLength = prefixLen,
.Prefix = { .si_family = addrFam }
},
.NextHop = { .si_family = addrFam },
.Loopback = false,
.AutoconfigureAddress = false,
.Immortal = false,
.Age = 0,
.Origin = 0
};
Err(getLuid(&row.InterfaceLuid deviceName, alloc));
if (addrFam == AF_INET6) {
Bits_memcpy(&row.DestinationPrefix.Prefix.Ipv6.sin6_addr, addrBytes, 15);
row.DestinationPrefix.Prefix.Ipv6.sin6_family = AF_INET6;
// set the gateway addr to the client's addr +1
uint64_t addr[2];
Bits_memcpy(addr, addrBytes, 16);
addr[1] = Endian_hostToBigEndian64(Endian_bigEndianToHost64(addr[1]) + 1);
if (!addr[1]) {
addr[0] = Endian_hostToBigEndian64(Endian_bigEndianToHost64(addr[0]) + 1);
}
// Bits_memcpy(&row.NextHop.Ipv6.sin6_addr, addr, 16);
} else {
Bits_memcpy(&row.DestinationPrefix.Prefix.Ipv4.sin_addr, addrBytes, 4);
row.DestinationPrefix.Prefix.Ipv4.sin_family = AF_INET;
uint32_t addr;
Bits_memcpy(&addr, addrBytes, 4);
addr = Endian_hostToBigEndian32(Endian_bigEndianToHost32(addr) + 1);
Bits_memcpy(&row.NextHop.Ipv4.sin_addr, &addr, 4);
}
//InitializeIpForwardEntry(&row);
uint8_t buff[sizeof(row) * 2 + 1];
Hex_encode(buff, sizeof(buff), (uint8_t*) &row, sizeof(row));
printf("%s %d\n", buff, row.SitePrefixLength);
// Hex_encode(buff, sizeof(buff), (uint8_t*) &row, sizeof(row));
// printf("%s %d<\n", buff, row.SitePrefixLength);
WinEr_check(alloc, CreateIpForwardEntry2(&row));
return NULL;
}
Err_DEFUN NetPlatform_addAddress(const char* interfaceName,
const uint8_t* address,
int prefixLen,
int addrFam,
struct Log* logger,
struct Allocator* tempAlloc)
{
MIB_UNICASTIPADDRESS_ROW ipRow = {
.PrefixOrigin = IpPrefixOriginUnchanged,
.SuffixOrigin = IpSuffixOriginUnchanged,
.ValidLifetime = 0xFFFFFFFF,
.PreferredLifetime = 0xFFFFFFFF,
.OnLinkPrefixLength = 0xFF
};
Err(getLuid(&ipRow.InterfaceLuid, interfaceName, tempAlloc));
ipRow.Address.si_family = addrFam;
if (addrFam == AF_INET6) {
Bits_memcpy(&ipRow.Address.Ipv6.sin6_addr, address, 16);
} else if (addrFam == AF_INET) {
Bits_memcpy(&ipRow.Address.Ipv4.sin_addr, address, 4);
} else {
Assert_true(0);
}
ipRow.OnLinkPrefixLength = prefixLen;
WinEr_check(tempAlloc, CreateUnicastIpAddressEntry(&ipRow));
if (0) {
// setupRoute was disabled in d7f5b302ac9215221428de81b9a496b40dcb3884
Err(setupRoute(interfaceName, address, prefixLen, addrFam, tempAlloc));
}
return NULL;
}
Err_DEFUN NetPlatform_setMTU(const char* interfaceName,
uint32_t mtu,
struct Log* logger,
struct Allocator* errAlloc)
{
// I looked all through the Windows API and setting the MTU is beyond me.
// But I do know how to do it through netsh.
// We know the connection names on Windows can't have any badly-behaved
// characters that would need escaping.
const char* format = ("netsh interface ipv6 set subinterface "
"\"%s\" mtu=%d");
// How much space do we need to fit the pattern substituted with the
// interface name? We ought to use _vscprintf, but the compiler chokes on
// its variable arguiment list. For now we overestimate: pattern length +
// interrface name length + estimated size of the MTU number according to
// + a byte for the null
// terminator.
uint32_t totalSize = strlen(format) + strlen(interfaceName) +
(CHAR_BIT * sizeof(uint32_t)) / 3 + 3 + 1;
// Make a buffer to prepare our command in
char buffer[totalSize];
// Fill in the interface name
snprintf(buffer, totalSize, format, interfaceName, mtu);
Log_debug(logger, "Going to run command: %s", buffer);
// Make the netsh call, and die if it returns the wrong thing.
WinEr_check(errAlloc, system(buffer));
// We should also configure the MTU for ipv4 (IpTunnel) case
const char* format1 = ("netsh interface ipv4 set subinterface "
"\"%s\" mtu=%d");
snprintf(buffer, totalSize, format1, interfaceName, mtu);
Log_debug(logger, "Going to run command: %s", buffer);
WinEr_check(errAlloc, system(buffer));
return NULL;
}
Err_DEFUN NetPlatform_setRoutes(const char* ifName,
struct Sockaddr** prefixSet,
int prefixCount,
struct Log* logger,
struct Allocator* tempAlloc)
{
Err_raise(tempAlloc, "NetPlatform_setRoutes is not implemented in this platform.");
}