piwalker/melonDS
1
0
Fork 0
mirror of https://github.com/melonDS-emu/melonDS.git synced 2024-11-14 21:37:42 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

start differenciating between direct and indirect LAN modes.

Browse Source 
indirect mode will use regular sockets and not pcap.
This commit is contained in:
Arisotura 2019-03-04 20:52:29 +01:00
parent 7a0c1af30b
commit 1e108ad7fb
7 changed files with 1081 additions and 9 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
melonDS.cbp
View File

@ -158,8 +158,10 @@
<Unit filename="src/libui_sdl/DlgInputConfig.h" />
<Unit filename="src/libui_sdl/DlgWifiSettings.cpp" />
<Unit filename="src/libui_sdl/DlgWifiSettings.h" />
<Unit filename="src/libui_sdl/LAN.cpp" />
<Unit filename="src/libui_sdl/LAN.h" />
<Unit filename="src/libui_sdl/LAN_PCap.cpp" />
<Unit filename="src/libui_sdl/LAN_PCap.h" />
<Unit filename="src/libui_sdl/LAN_Socket.cpp" />
<Unit filename="src/libui_sdl/LAN_Socket.h" />
<Unit filename="src/libui_sdl/Platform.cpp" />
<Unit filename="src/libui_sdl/libui/common/areaevents.c">
<Option compilerVar="CC" />

4
src/Wifi.cpp
View File

@ -28,8 +28,8 @@
namespace Wifi
{
#define WIFI_LOG printf
//#define WIFI_LOG(...) {}
//#define WIFI_LOG printf
#define WIFI_LOG(...) {}
u8 RAM[0x2000];
u16 IO[0x1000>>1];

0
src/libui_sdl/LAN.cpp → src/libui_sdl/LAN_PCap.cpp
View File

8
src/libui_sdl/LAN.h → src/libui_sdl/LAN_PCap.h
View File

@ -16,12 +16,12 @@
with melonDS. If not, see http://www.gnu.org/licenses/.
*/
#ifndef LAN_H
#define LAN_H
#ifndef LAN_PCAP_H
#define LAN_PCAP_H
#include "../types.h"
namespace LAN
namespace LAN_PCap
{
typedef struct
@ -55,4 +55,4 @@ int RecvPacket(u8* data);
}
#endif // LAN_H
#endif // LAN_PCAP_H

977
src/libui_sdl/LAN_Socket.cpp Normal file
View File

@ -0,0 +1,977 @@
/*
Copyright 2016-2019 Arisotura
This file is part of melonDS.
melonDS is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
*/
// LAN interface. Currently powered by libpcap, may change.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <SDL2/SDL.h>
#include <pcap/pcap.h>
#include "Wifi.h"
#include "LAN.h"
#include "../Config.h"
#ifdef __WIN32__
#include <iphlpapi.h>
#else
// Linux includes go here
#endif
// welp
#ifndef PCAP_OPENFLAG_PROMISCUOUS
#define PCAP_OPENFLAG_PROMISCUOUS 1
#endif
#define DECL_PCAP_FUNC(ret, name, args, args2) \
typedef ret (*type_##name) args; \
type_##name ptr_##name = NULL; \
ret name args { return ptr_##name args2; }
DECL_PCAP_FUNC(int, pcap_findalldevs, (pcap_if_t** alldevs, char* errbuf), (alldevs,errbuf))
DECL_PCAP_FUNC(void, pcap_freealldevs, (pcap_if_t* alldevs), (alldevs))
DECL_PCAP_FUNC(pcap_t*, pcap_open_live, (const char* src, int snaplen, int flags, int readtimeout, char* errbuf), (src,snaplen,flags,readtimeout,errbuf))
DECL_PCAP_FUNC(void, pcap_close, (pcap_t* dev), (dev))
DECL_PCAP_FUNC(int, pcap_setnonblock, (pcap_t* dev, int nonblock, char* errbuf), (dev,nonblock,errbuf))
DECL_PCAP_FUNC(int, pcap_sendpacket, (pcap_t* dev, const u_char* data, int len), (dev,data,len))
DECL_PCAP_FUNC(int, pcap_dispatch, (pcap_t* dev, int num, pcap_handler callback, u_char* data), (dev,num,callback,data))
DECL_PCAP_FUNC(const u_char*, pcap_next, (pcap_t* dev, struct pcap_pkthdr* hdr), (dev,hdr))
namespace LAN
{
const char* PCapLibNames[] =
{
#ifdef __WIN32__
// TODO: name for npcap in non-WinPCap mode
"wpcap.dll",
#else
// Linux lib names
"libpcap.so.1",
"libpcap.so",
#endif
NULL
};
AdapterData* Adapters = NULL;
int NumAdapters = 0;
void* PCapLib = NULL;
pcap_t* PCapAdapter = NULL;
AdapterData* PCapAdapterData;
u8 PCapPacketBuffer[2048];
int PCapPacketLen;
volatile int PCapRXNum;
u16 IPv4ID;
typedef struct
{
u8 DestIP[4];
u16 DestPort;
// 0: unused
// 1: connected
u8 Status;
} TCPSocket;
TCPSocket TCPSocketList[64];
#define LOAD_PCAP_FUNC(sym) \
ptr_##sym = (type_##sym)SDL_LoadFunction(lib, #sym); \
if (!ptr_##sym) return false;
bool TryLoadPCap(void* lib)
{
LOAD_PCAP_FUNC(pcap_findalldevs)
LOAD_PCAP_FUNC(pcap_freealldevs)
LOAD_PCAP_FUNC(pcap_open_live)
LOAD_PCAP_FUNC(pcap_close)
LOAD_PCAP_FUNC(pcap_setnonblock)
LOAD_PCAP_FUNC(pcap_sendpacket)
LOAD_PCAP_FUNC(pcap_dispatch)
LOAD_PCAP_FUNC(pcap_next)
return true;
}
bool Init()
{
// TODO: how to deal with cases where an adapter is unplugged or changes config??
if (PCapLib) return true;
PCapLib = NULL;
PCapAdapter = NULL;
PCapPacketLen = 0;
PCapRXNum = 0;
IPv4ID = 1;
memset(TCPSocketList, 0, sizeof(TCPSocketList));
for (int i = 0; PCapLibNames[i]; i++)
{
void* lib = SDL_LoadObject(PCapLibNames[i]);
if (!lib) continue;
if (!TryLoadPCap(lib))
{
SDL_UnloadObject(lib);
continue;
}
printf("PCap: lib %s, init successful\n", PCapLibNames[i]);
PCapLib = lib;
break;
}
if (PCapLib == NULL)
{
printf("PCap: init failed\n");
return false;
}
char errbuf[PCAP_ERRBUF_SIZE];
int ret;
pcap_if_t* alldevs;
ret = pcap_findalldevs(&alldevs, errbuf);
if (ret < 0 || alldevs == NULL)
{
printf("PCap: no devices available\n");
return false;
}
pcap_if_t* dev = alldevs;
while (dev) { NumAdapters++; dev = dev->next; }
Adapters = new AdapterData[NumAdapters];
memset(Adapters, 0, sizeof(AdapterData)*NumAdapters);
AdapterData* adata = &Adapters[0];
dev = alldevs;
while (dev)
{
adata->Internal = dev;
// hax
int len = strlen(dev->name);
len -= 12; if (len > 127) len = 127;
strncpy(adata->DeviceName, &dev->name[12], len);
adata->DeviceName[len] = '\0';
dev = dev->next;
adata++;
}
#ifdef __WIN32__
ULONG bufsize = 16384;
IP_ADAPTER_ADDRESSES* buf = (IP_ADAPTER_ADDRESSES*)HeapAlloc(GetProcessHeap(), 0, bufsize);
ULONG uret = GetAdaptersAddresses(AF_INET, 0, NULL, buf, &bufsize);
if (uret == ERROR_BUFFER_OVERFLOW)
{
HeapFree(GetProcessHeap(), 0, buf);
buf = (IP_ADAPTER_ADDRESSES*)HeapAlloc(GetProcessHeap(), 0, bufsize);
uret = GetAdaptersAddresses(AF_INET, 0, NULL, buf, &bufsize);
}
if (uret != ERROR_SUCCESS)
{
printf("GetAdaptersAddresses() shat itself: %08X\n", ret);
return false;
}
for (int i = 0; i < NumAdapters; i++)
{
adata = &Adapters[i];
IP_ADAPTER_ADDRESSES* addr = buf;
while (addr)
{
if (strcmp(addr->AdapterName, adata->DeviceName))
{
addr = addr->Next;
continue;
}
WideCharToMultiByte(CP_UTF8, 0, addr->FriendlyName, 127, adata->FriendlyName, 127, NULL, NULL);
adata->FriendlyName[127] = '\0';
WideCharToMultiByte(CP_UTF8, 0, addr->Description, 127, adata->Description, 127, NULL, NULL);
adata->Description[127] = '\0';
if (addr->PhysicalAddressLength != 6)
{
printf("weird MAC addr length %d for %s\n", addr->PhysicalAddressLength, addr->AdapterName);
}
else
memcpy(adata->MAC, addr->PhysicalAddress, 6);
IP_ADAPTER_UNICAST_ADDRESS* ipaddr = addr->FirstUnicastAddress;
while (ipaddr)
{
SOCKADDR* sa = ipaddr->Address.lpSockaddr;
if (sa->sa_family == AF_INET)
{
struct in_addr sa4 = ((sockaddr_in*)sa)->sin_addr;
memcpy(adata->IP_v4, &sa4.S_un.S_addr, 4);
}
ipaddr = ipaddr->Next;
}
IP_ADAPTER_DNS_SERVER_ADDRESS* dnsaddr = addr->FirstDnsServerAddress;
int ndns = 0;
while (dnsaddr)
{
SOCKADDR* sa = dnsaddr->Address.lpSockaddr;
if (sa->sa_family == AF_INET)
{
struct in_addr sa4 = ((sockaddr_in*)sa)->sin_addr;
memcpy(adata->DNS[ndns++], &sa4.S_un.S_addr, 4);
}
if (ndns >= 8) break;
dnsaddr = dnsaddr->Next;
}
if (addr->Dhcpv4Enabled && addr->Dhcpv4Server.lpSockaddr)
{
SOCKADDR* sa = addr->Dhcpv4Server.lpSockaddr;
struct in_addr sa4 = ((sockaddr_in*)sa)->sin_addr;
memcpy(adata->DHCP_IP_v4, &sa4.S_un.S_addr, 4);
}
else
memset(adata->DHCP_IP_v4, 0, 4);
break;
}
}
HeapFree(GetProcessHeap(), 0, buf);
#else
// TODO
#endif // __WIN32__
// open pcap device
PCapAdapterData = &Adapters[0];
for (int i = 0; i < NumAdapters; i++)
{
if (!strncmp(Adapters[i].DeviceName, Config::LANDevice, 128))
PCapAdapterData = &Adapters[i];
}
dev = (pcap_if_t*)PCapAdapterData->Internal;
PCapAdapter = pcap_open_live(dev->name, 2048, PCAP_OPENFLAG_PROMISCUOUS, 1, errbuf);
if (!PCapAdapter)
{
printf("PCap: failed to open adapter\n");
return false;
}
pcap_freealldevs(alldevs);
for (int ntries = 0; ntries < 4; ntries++)
{
bool good = false;
// get router MAC
printf("DHCP: %d.%d.%d.%d\n",
PCapAdapterData->DHCP_IP_v4[0], PCapAdapterData->DHCP_IP_v4[1],
PCapAdapterData->DHCP_IP_v4[2], PCapAdapterData->DHCP_IP_v4[3]);
u8 arp[64];
u8* out = &arp[0];
*out++ = 0xFF; *out++ = 0xFF; *out++ = 0xFF;
*out++ = 0xFF; *out++ = 0xFF; *out++ = 0xFF;
memcpy(out, PCapAdapterData->MAC, 6); out += 6;
*(u16*)out = htons(0x0806); out += 2;
*(u16*)out = htons(0x0001); out += 2;
*(u16*)out = htons(0x0800); out += 2;
*out++ = 6;
*out++ = 4;
*(u16*)out = htons(0x0001); out += 2;
memcpy(out, PCapAdapterData->MAC, 6); out += 6;
memcpy(out, PCapAdapterData->IP_v4, 4); out += 4;
*out++ = 0; *out++ = 0; *out++ = 0;
*out++ = 0; *out++ = 0; *out++ = 0;
memcpy(out, PCapAdapterData->DHCP_IP_v4, 4); out += 4;
u32 len = (u32)(out - &arp[0]);
pcap_sendpacket(PCapAdapter, arp, len);
for (int t = 0; t < 16; t++)
{
struct pcap_pkthdr hdr;
const u8* rep = pcap_next(PCapAdapter, &hdr);
if (!rep) continue;
if (hdr.len < 0x2A) continue;
if (memcmp(&rep[0], PCapAdapterData->MAC, 6))
continue;
if (ntohs(*(u16*)&rep[12]) != 0x0806)
continue;
if (ntohs(*(u16*)&rep[14]) != 0x0001)
continue;
if (ntohs(*(u16*)&rep[16]) != 0x0800)
continue;
if (ntohs(*(u16*)&rep[18]) != 0x0604)
continue;
if (ntohs(*(u16*)&rep[20]) != 0x0002)
continue;
if (memcmp(&rep[28], PCapAdapterData->DHCP_IP_v4, 4))
continue;
printf("DHCP MAC: %02X:%02X:%02X:%02X:%02X:%02X\n",
rep[22], rep[23], rep[24],
rep[25], rep[26], rep[27]);
memcpy(PCapAdapterData->DHCP_MAC, &rep[22], 6);
good = true;
break;
}
if (good) break;
}
if (pcap_setnonblock(PCapAdapter, 1, errbuf) < 0)
{
printf("PCap: failed to set nonblocking mode\n");
pcap_close(PCapAdapter); PCapAdapter = NULL;
return false;
}
return true;
}
void DeInit()
{
if (PCapLib)
{
if (PCapAdapter)
{
pcap_close(PCapAdapter);
PCapAdapter = NULL;
}
SDL_UnloadObject(PCapLib);
PCapLib = NULL;
}
}
bool HandleIncomingIPFrame(u8* data, int len)
{
const u32 serverip = 0x0A404001;
const u32 clientip = 0x0A404010;
if (memcmp(&data[0x1E], PCapAdapterData->IP_v4, 4))
return false;
u8 protocol = data[0x17];
//memcpy(&data[6], &PCapAdapterData->DHCP_MAC[0], 6);
memcpy(&data[0], Wifi::GetMAC(), 6);
data[6] = 0x00; data[7] = 0xAB; data[8] = 0x33;
data[9] = 0x28; data[10] = 0x99; data[11] = 0x44;
*(u32*)&data[0x1E] = htonl(clientip);
u8* ipheader = &data[0xE];
u8* protoheader = &data[0x22];
// IP checksum
u32 tmp = 0;
*(u16*)&ipheader[10] = 0;
for (int i = 0; i < 20; i += 2)
tmp += ntohs(*(u16*)&ipheader[i]);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
*(u16*)&ipheader[10] = htons(tmp);
if (protocol == 0x11)
{
u32 udplen = ntohs(*(u16*)&protoheader[4]);
// UDP checksum
tmp = 0;
*(u16*)&protoheader[6] = 0;
tmp += ntohs(*(u16*)&ipheader[12]);
tmp += ntohs(*(u16*)&ipheader[14]);
tmp += ntohs(*(u16*)&ipheader[16]);
tmp += ntohs(*(u16*)&ipheader[18]);
tmp += ntohs(0x1100);
tmp += udplen;
for (u8* i = protoheader; i < &protoheader[udplen-1]; i += 2)
tmp += ntohs(*(u16*)i);
if (udplen & 1) tmp += (protoheader[udplen-1] << 8);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
if (tmp == 0) tmp = 0xFFFF;
*(u16*)&protoheader[6] = htons(tmp);
}
else if (protocol == 0x06)
{
u32 tcplen = ntohs(*(u16*)&ipheader[2]) - 0x14;
u16 srcport = ntohs(*(u16*)&protoheader[0]);
u16 dstport = ntohs(*(u16*)&protoheader[2]);
u16 flags = ntohs(*(u16*)&protoheader[12]);
// TODO: check if they send a FIN, I guess
int sockid = -1;
for (int i = 0; i < (sizeof(TCPSocketList)/sizeof(TCPSocket)); i++)
{
TCPSocket* sock = &TCPSocketList[i];
if (sock->Status == 1 && !memcmp(&sock->DestIP, &ipheader[12], 4) && sock->DestPort == srcport)
{
sockid = i;
break;
}
}
if (sockid == -1)
{
return true;
}
// TCP checksum
tmp = 0;
*(u16*)&protoheader[16] = 0;
tmp += ntohs(*(u16*)&ipheader[12]);
tmp += ntohs(*(u16*)&ipheader[14]);
tmp += ntohs(*(u16*)&ipheader[16]);
tmp += ntohs(*(u16*)&ipheader[18]);
tmp += ntohs(0x0600);
tmp += tcplen;
for (u8* i = protoheader; i < &protoheader[tcplen-1]; i += 2)
tmp += ntohs(*(u16*)i);
if (tcplen & 1) tmp += (protoheader[tcplen-1] << 8);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
*(u16*)&protoheader[16] = htons(tmp);
}
return false;
}
void RXCallback(u_char* blarg, const struct pcap_pkthdr* header, const u_char* data)
{
while (PCapRXNum > 0);
if (header->len > 2048-64) return;
PCapPacketLen = header->len;
memcpy(PCapPacketBuffer, data, PCapPacketLen);
PCapRXNum = 1;
if (!Config::DirectLAN)
{
u16 ethertype = ntohs(*(u16*)&data[0xC]);
if (ethertype == 0x0800) // IPv4
{
if (HandleIncomingIPFrame(PCapPacketBuffer, header->len))
PCapRXNum = 0;
}
}
}
u32 zarp=0;
bool HandleDHCPFrame(u8* data, int len)
{
const u32 serverip = 0x0A404001;
const u32 clientip = 0x0A404010;
u8 type = 0xFF;
u32 transid = *(u32*)&data[0x2E];
zarp=transid;
u8* options = &data[0x11A];
for (;;)
{
if (options >= &data[len]) break;
u8 opt = *options++;
if (opt == 255) break;
u8 len = *options++;
switch (opt)
{
case 53: // frame type
type = options[0];
break;
}
options += len;
}
if (type == 0xFF)
{
printf("DHCP: bad frame\n");
return false;
}
printf("DHCP: frame type %d, transid %08X\n", type, transid);
if (type == 1 || // discover
type == 3) // request
{
u8 resp[512];
u8* out = &resp[0];
// ethernet
memcpy(out, &data[6], 6); out += 6;
*out++ = 0x00; *out++ = 0xAB; *out++ = 0x33;
*out++ = 0x28; *out++ = 0x99; *out++ = 0x44;
*(u16*)out = htons(0x0800); out += 2;
// IP
u8* ipheader = out;
*out++ = 0x45;
*out++ = 0x00;
*(u16*)out = 0; out += 2; // total length
*(u16*)out = htons(IPv4ID); out += 2; IPv4ID++;
*out++ = 0x00;
*out++ = 0x00;
*out++ = 0x80; // TTL
*out++ = 0x11; // protocol (UDP)
*(u16*)out = 0; out += 2; // checksum
*(u32*)out = htonl(serverip); out += 4; // source IP
if (type == 1)
{
*(u32*)out = htonl(0xFFFFFFFF); out += 4; // destination IP
}
else if (type == 3)
{
*(u32*)out = htonl(clientip); out += 4; // destination IP
}
// UDP
u8* udpheader = out;
*(u16*)out = htons(67); out += 2; // source port
*(u16*)out = htons(68); out += 2; // destination port
*(u16*)out = 0; out += 2; // length
*(u16*)out = 0; out += 2; // checksum
// DHCP
u8* body = out;
*out++ = 0x02;
*out++ = 0x01;
*out++ = 0x06;
*out++ = 0x00;
*(u32*)out = transid; out += 4;
*(u16*)out = 0; out += 2; // seconds elapsed
*(u16*)out = 0; out += 2;
*(u32*)out = htonl(0x00000000); out += 4; // client IP
*(u32*)out = htonl(clientip); out += 4; // your IP
*(u32*)out = htonl(serverip); out += 4; // server IP
*(u32*)out = htonl(0x00000000); out += 4; // gateway IP
memcpy(out, &data[6], 6); out += 6;
memset(out, 0, 10); out += 10;
memset(out, 0, 192); out += 192;
*(u32*)out = 0x63538263; out += 4; // DHCP magic
// DHCP options
*out++ = 53; *out++ = 1;
*out++ = (type==1) ? 2 : 5; // DHCP type: offer/ack
*out++ = 1; *out++ = 4;
*(u32*)out = htonl(0xFFFFFF00); out += 4; // subnet mask
*out++ = 3; *out++ = 4;
*(u32*)out = htonl(serverip); out += 4; // router
*out++ = 51; *out++ = 4;
*(u32*)out = htonl(442030); out += 4; // lease time
*out++ = 54; *out++ = 4;
*(u32*)out = htonl(serverip); out += 4; // DHCP server
u8 numdns = 0;
for (int i = 0; i < 8; i++)
{
if (*(u32*)&PCapAdapterData->DNS[i][0] != 0)
numdns++;
}
*out++ = 6; *out++ = 4*numdns;
for (int i = 0; i < 8; i++)
{
u32 dnsip = *(u32*)&PCapAdapterData->DNS[i][0];
if (dnsip != 0)
{
*(u32*)out = dnsip; out += 4;
}
}
*out++ = 0xFF;
memset(out, 0, 20); out += 20;
// lengths
u32 framelen = (u32)(out - &resp[0]);
if (framelen & 1) { *out++ = 0; framelen++; }
*(u16*)&ipheader[2] = htons(framelen - 0xE);
*(u16*)&udpheader[4] = htons(framelen - (0xE + 0x14));
// IP checksum
u32 tmp = 0;
for (int i = 0; i < 20; i += 2)
tmp += ntohs(*(u16*)&ipheader[i]);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
*(u16*)&ipheader[10] = htons(tmp);
// UDP checksum
// (note: normally not mandatory, but some older sgIP versions require it)
tmp = 0;
tmp += ntohs(*(u16*)&ipheader[12]);
tmp += ntohs(*(u16*)&ipheader[14]);
tmp += ntohs(*(u16*)&ipheader[16]);
tmp += ntohs(*(u16*)&ipheader[18]);
tmp += ntohs(0x1100);
tmp += (u32)(out - udpheader);
for (u8* i = udpheader; i < out; i += 2)
tmp += ntohs(*(u16*)i);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
if (tmp == 0) tmp = 0xFFFF;
*(u16*)&udpheader[6] = htons(tmp);
// TODO: if there is already a packet queued, this will overwrite it
// that being said, this will only happen during DHCP setup, so probably
// not a big deal
PCapPacketLen = framelen;
memcpy(PCapPacketBuffer, resp, PCapPacketLen);
PCapRXNum = 1;
// DEBUG!!
//pcap_sendpacket(PCapAdapter, data, len);
//pcap_sendpacket(PCapAdapter, resp, framelen);
return true;
}
return false;
}
bool HandleIPFrame(u8* data, int len)
{
const u32 serverip = 0x0A404001;
const u32 clientip = 0x0A404010;
// debug
//pcap_sendpacket(PCapAdapter, data, len);
u8 protocol = data[0x17];
// any kind of IPv4 frame that isn't DHCP
// we do NAT and forward it to the network
// like:
// melonRouter -> host
// destination MAC set to host MAC
// source MAC set to melonRouter MAC
memcpy(&data[0], &PCapAdapterData->DHCP_MAC[0], 6);
memcpy(&data[6], &PCapAdapterData->MAC[0], 6);
*(u32*)&data[0x1A] = *(u32*)&PCapAdapterData->IP_v4[0];
u8* ipheader = &data[0xE];
u8* protoheader = &data[0x22];
// IP checksum
u32 tmp = 0;
*(u16*)&ipheader[10] = 0;
for (int i = 0; i < 20; i += 2)
tmp += ntohs(*(u16*)&ipheader[i]);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
*(u16*)&ipheader[10] = htons(tmp);
if (protocol == 0x11)
{
u32 udplen = ntohs(*(u16*)&protoheader[4]);
// UDP checksum
tmp = 0;
*(u16*)&protoheader[6] = 0;
tmp += ntohs(*(u16*)&ipheader[12]);
tmp += ntohs(*(u16*)&ipheader[14]);
tmp += ntohs(*(u16*)&ipheader[16]);
tmp += ntohs(*(u16*)&ipheader[18]);
tmp += ntohs(0x1100);
tmp += udplen;
for (u8* i = protoheader; i < &protoheader[udplen]; i += 2)
tmp += ntohs(*(u16*)i);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
if (tmp == 0) tmp = 0xFFFF;
*(u16*)&protoheader[6] = htons(tmp);
}
else if (protocol == 0x06)
{
u32 tcplen = ntohs(*(u16*)&ipheader[2]) - 0x14;
u16 srcport = ntohs(*(u16*)&protoheader[0]);
u16 dstport = ntohs(*(u16*)&protoheader[2]);
u16 flags = ntohs(*(u16*)&protoheader[12]);
if (flags & 0x002) // SYN
{
int sockid = -1;
for (int i = 0; i < (sizeof(TCPSocketList)/sizeof(TCPSocket)); i++)
{
TCPSocket* sock = &TCPSocketList[i];
if (sock->Status == 1 && !memcmp(&sock->DestIP, &ipheader[16], 4) && sock->DestPort == dstport)
{
printf("LANMAGIC: duplicate TCP socket\n");
sockid = i;
break;
}
}
if (sockid == -1)
{
for (int i = 0; i < (sizeof(TCPSocketList)/sizeof(TCPSocket)); i++)
{
TCPSocket* sock = &TCPSocketList[i];
if (sock->Status == 0)
{
sockid = i;
break;
}
}
}
if (sockid == -1)
{
printf("LANMAGIC: !! TCP SOCKET LIST FULL\n");
return true;
}
printf("LANMAGIC: opening TCP socket #%d to %d.%d.%d.%d:%d\n",
sockid,
ipheader[16], ipheader[17], ipheader[18], ipheader[19],
dstport);
// keep track of it
// (TODO: also keep track of source port?)
TCPSocket* sock = &TCPSocketList[sockid];
sock->Status = 1;
memcpy(sock->DestIP, &ipheader[16], 4);
sock->DestPort = dstport;
}
else
{
int sockid = -1;
for (int i = 0; i < (sizeof(TCPSocketList)/sizeof(TCPSocket)); i++)
{
TCPSocket* sock = &TCPSocketList[i];
if (sock->Status == 1 && !memcmp(&sock->DestIP, &ipheader[16], 4) && sock->DestPort == dstport)
{
sockid = i;
break;
}
}
if (sockid == -1)
{
printf("LANMAGIC: bad TCP packet\n");
return true;
}
if (flags & 0x001) // FIN
{
// TODO: cleverer termination?
// also timeout etc
TCPSocketList[sockid].Status = 0;
}
}
// TCP checksum
tmp = 0;
*(u16*)&protoheader[16] = 0;
tmp += ntohs(*(u16*)&ipheader[12]);
tmp += ntohs(*(u16*)&ipheader[14]);
tmp += ntohs(*(u16*)&ipheader[16]);
tmp += ntohs(*(u16*)&ipheader[18]);
tmp += ntohs(0x0600);
tmp += tcplen;
for (u8* i = protoheader; i < &protoheader[tcplen]; i += 2)
tmp += ntohs(*(u16*)i);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
tmp ^= 0xFFFF;
if (tmp == 0) tmp = 0xFFFF;
*(u16*)&protoheader[16] = htons(tmp);
}
return false;
}
bool HandleARPFrame(u8* data, int len)
{
const u32 serverip = 0x0A404001;
const u32 clientip = 0x0A404010;
u16 protocol = ntohs(*(u16*)&data[0x10]);
if (protocol != 0x0800) return false;
u16 op = ntohs(*(u16*)&data[0x14]);
u32 targetip = ntohl(*(u32*)&data[0x26]);
// TODO: handle ARP to the client
// this only handles ARP to the DHCP/router
if (op == 1 && targetip == serverip)
{
// opcode 1=req 2=reply
// sender MAC
// sender IP
// target MAC
// target IP
u8 resp[64];
u8* out = &resp[0];
// ethernet
memcpy(out, &data[6], 6); out += 6;
*out++ = 0x00; *out++ = 0xAB; *out++ = 0x33;
*out++ = 0x28; *out++ = 0x99; *out++ = 0x44;
*(u16*)out = htons(0x0806); out += 2;
// ARP
*(u16*)out = htons(0x0001); out += 2; // hardware type
*(u16*)out = htons(0x0800); out += 2; // protocol
*out++ = 6; // MAC address size
*out++ = 4; // IP address size
*(u16*)out = htons(0x0002); out += 2; // opcode
*out++ = 0x00; *out++ = 0xAB; *out++ = 0x33;
*out++ = 0x28; *out++ = 0x99; *out++ = 0x44;
*(u32*)out = htonl(targetip); out += 4;
memcpy(out, &data[0x16], 6+4); out += 6+4;
u32 framelen = (u32)(out - &resp[0]);
// TODO: if there is already a packet queued, this will overwrite it
// that being said, this will only happen during DHCP setup, so probably
// not a big deal
PCapPacketLen = framelen;
memcpy(PCapPacketBuffer, resp, PCapPacketLen);
PCapRXNum = 1;
// also broadcast them to the network
pcap_sendpacket(PCapAdapter, data, len);
pcap_sendpacket(PCapAdapter, resp, framelen);
return true;
}
return false;
}
bool HandlePacket(u8* data, int len)
{
u16 ethertype = ntohs(*(u16*)&data[0xC]);
if (ethertype == 0x0800) // IPv4
{
u8 protocol = data[0x17];
if (protocol == 0x11) // UDP
{
u16 srcport = ntohs(*(u16*)&data[0x22]);
u16 dstport = ntohs(*(u16*)&data[0x24]);
if (srcport == 68 && dstport == 67) // DHCP
{
printf("LANMAGIC: DHCP packet\n");
return HandleDHCPFrame(data, len);
}
}
printf("LANMAGIC: IP frame, doing NAT\n");
return HandleIPFrame(data, len);
}
else if (ethertype == 0x0806) // ARP
{
printf("LANMAGIC: ARP\n");
return HandleARPFrame(data, len);
}
return false;
}
int SendPacket(u8* data, int len)
{
if (PCapAdapter == NULL)
return 0;
if (len > 2048)
{
printf("LAN_SendPacket: error: packet too long (%d)\n", len);
return 0;
}
if (!Config::DirectLAN)
{
if (HandlePacket(data, len))
return len;
}
pcap_sendpacket(PCapAdapter, data, len);
// TODO: check success
return len;
}
int RecvPacket(u8* data)
{
if (PCapAdapter == NULL)
return 0;
int ret = 0;
if (PCapRXNum > 0)
{
memcpy(data, PCapPacketBuffer, PCapPacketLen);
ret = PCapPacketLen;
PCapRXNum = 0;
}
pcap_dispatch(PCapAdapter, 1, RXCallback, NULL);
return ret;
}
}

38
src/libui_sdl/LAN_Socket.h Normal file
View File

@ -0,0 +1,38 @@
/*
Copyright 2016-2019 Arisotura
This file is part of melonDS.
melonDS is free software: you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation, either version 3 of the License, or (at your option)
any later version.
melonDS 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 melonDS. If not, see http://www.gnu.org/licenses/.
*/
#ifndef LAN_SOCKET_H
#define LAN_SOCKET_H
#include "../types.h"
namespace LAN_Socket
{
//
bool Init();
void DeInit();
int SendPacket(u8* data, int len);
int RecvPacket(u8* data);
}
#endif // LAN_SOCKET_H

57
src/libui_sdl/main.cpp
View File

@ -1683,7 +1683,7 @@ void ApplyNewSettings(int type)
EmuRunning = prevstatus;
}
u16 zogg(u16 val) { return (val>>8)|(val<<8);}
int main(int argc, char** argv)
{
srand(time(NULL));
@ -1691,6 +1691,61 @@ int main(int argc, char** argv)
printf("melonDS " MELONDS_VERSION "\n");
printf(MELONDS_URL "\n");
{
/*u8 shit[] =
{
0x84, 0x7A, 0x88, 0x1E, 0x8D, 0x1E, 0x34, 0x02, 0x86, 0xC5, 0x45, 0x2C, 0x08, 0x00, 0x45, 0x00,
0x00, 0x28, 0x12, 0x00, 0x00, 0x00, 0x80, 0x06, 0x37, 0x8D, 0xC0, 0xA8, 0x06, 0x5E, 0xA3, 0xAC,
0x86, 0x90, 0x9D, 0xC5, 0x14, 0x46, 0xF9, 0xE0, 0x5B, 0x65, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x05, 0x78, 0x00, 0x00, 0x00, 0x00, 0x03, 0x69, 0x72, 0x63, 0x07, 0x67, 0x62, 0x61, 0x74, 0x65,
0x6D, 0x70, 0x03, 0x6E
};*/
u8 shit[] =
{
0x00, 0xAB, 0x33, 0x28, 0x99, 0x44, 0x00, 0x09, 0xBF, 0x53, 0xC4, 0x49, 0x08, 0x00, 0x45, 0x00,
0x00, 0x28, 0x7E, 0x00, 0x00, 0x00, 0x80, 0x06, 0x48, 0x43, 0x0A, 0x40, 0x40, 0x10, 0xA3, 0xAC,
0x86, 0x90, 0x9C, 0x99, 0x14, 0x46, 0x31, 0x2F, 0x08, 0x59, 0x00, 0x00, 0x00, 0x00, 0x50, 0x02,
0x05, 0x78, 0x00, 0x00, 0x00, 0x00, 0x03, 0x69, 0x72, 0x63, 0x07, 0x67, 0x62, 0x61, 0x74, 0x65,
0x6D, 0x70, 0x03, 0x6E
};
// 4B76 (B489)
u32 len=0x44;
u8* ipheader = &shit[0xE];
u8* protoheader = &shit[0x22];
u32 tcplen = 0x14;//len-0x22;
// TCP checksum
u32 tmp = 0;
*(u16*)&protoheader[16] = 0;
tmp += zogg(*(u16*)&ipheader[12]);
printf("%04X %04X\n", zogg(*(u16*)&ipheader[12]), tmp);
tmp += zogg(*(u16*)&ipheader[14]);
printf("%04X %04X\n", zogg(*(u16*)&ipheader[14]), tmp);
tmp += zogg(*(u16*)&ipheader[16]);
printf("%04X %04X\n", zogg(*(u16*)&ipheader[16]), tmp);
tmp += zogg(*(u16*)&ipheader[18]);
printf("%04X %04X\n", zogg(*(u16*)&ipheader[18]), tmp);
tmp += zogg(0x0600);
printf("%04X %04X\n", zogg(0x600), tmp);
tmp += tcplen;
printf("%04X %04X\n", tcplen, tmp);
for (u8* i = protoheader; i < &protoheader[tcplen-1]; i += 2)
{
tmp += zogg(*(u16*)i);
printf("plarff: %d (%d) -> %04X %04X\n",
(u32)(i-protoheader), (u32)(i-&shit[0]),
zogg(*(u16*)i), tmp);
}
if (tcplen & 1) tmp += (protoheader[tcplen-1] << 8);
printf("tmp1=%04X\n", tmp);
while (tmp >> 16)
tmp = (tmp & 0xFFFF) + (tmp >> 16);
printf("tmp2=%04X\n", tmp);
tmp ^= 0xFFFF;
printf("chk = %04X\n", (tmp));
printf("expected = B1D5, bad = 2E8C\n");
}
if (argc > 0 && strlen(argv[0]) > 0)
{
int len = strlen(argv[0]);