AMajor/SoftEtherVPN
1
0
Fork 0
mirror of https://github.com/SoftEtherVPN/SoftEtherVPN.git synced 2024-11-22 17:39:53 +03:00
Code Releases Activity

Auto formatting with AStyle

Browse Source
This commit is contained in:
Evengard 2020-05-11 17:18:55 +03:00
parent 1d6a4d3ec8
commit f627b64264
8 changed files with 727 additions and 640 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

142
src/Cedar/IPC.c
View File

@ -37,7 +37,7 @@ bool ParseAndExtractMsChapV2InfoFromPassword(IPC_MSCHAP_V2_AUTHINFO *d, char *pa
b4 = StrToBin(t->Token[5]); b4 = StrToBin(t->Token[5]);
if (IsEmptyStr(t->Token[1]) == false && b1->Size == 16 && b2->Size == 16 && b3->Size == 24 if (IsEmptyStr(t->Token[1]) == false && b1->Size == 16 && b2->Size == 16 && b3->Size == 24
&& b4->Size == 8) && b4->Size == 8)
{ {
UINT64 eap_client_ptr = 0; UINT64 eap_client_ptr = 0;
@ -226,20 +226,20 @@ IPC *NewIPCByParam(CEDAR *cedar, IPC_PARAM *param, UINT *error_code)
} }
ipc = NewIPC(cedar, param->ClientName, param->Postfix, param->HubName, ipc = NewIPC(cedar, param->ClientName, param->Postfix, param->HubName,
param->UserName, param->Password, error_code, &param->ClientIp, param->UserName, param->Password, error_code, &param->ClientIp,
param->ClientPort, &param->ServerIp, param->ServerPort, param->ClientPort, &param->ServerIp, param->ServerPort,
param->ClientHostname, param->CryptName, param->ClientHostname, param->CryptName,
param->BridgeMode, param->Mss, NULL, param->ClientCertificate, param->Layer); param->BridgeMode, param->Mss, NULL, param->ClientCertificate, param->Layer);
return ipc; return ipc;
} }
// Start a new IPC connection // Start a new IPC connection
IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char *username, char *password, IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char *username, char *password,
UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port, UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port,
char *client_hostname, char *crypt_name, char *client_hostname, char *crypt_name,
bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate, bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate,
UINT layer) UINT layer)
{ {
IPC *ipc; IPC *ipc;
UINT dummy_int = 0; UINT dummy_int = 0;
@ -444,7 +444,7 @@ IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char
} }
if (ParseWelcomeFromPack(p, ipc->SessionName, sizeof(ipc->SessionName), if (ParseWelcomeFromPack(p, ipc->SessionName, sizeof(ipc->SessionName),
ipc->ConnectionName, sizeof(ipc->ConnectionName), &ipc->Policy) == false) ipc->ConnectionName, sizeof(ipc->ConnectionName), &ipc->Policy) == false)
{ {
err = ERR_PROTOCOL_ERROR; err = ERR_PROTOCOL_ERROR;
FreePack(p); FreePack(p);
@ -591,7 +591,7 @@ void FreeIPC(IPC *ipc)
FreeInterruptManager(ipc->Interrupt); FreeInterruptManager(ipc->Interrupt);
for (i = 0;i < LIST_NUM(ipc->ArpTable);i++) for (i = 0; i < LIST_NUM(ipc->ArpTable); i++)
{ {
IPC_ARP *a = LIST_DATA(ipc->ArpTable, i); IPC_ARP *a = LIST_DATA(ipc->ArpTable, i);
IPCFreeARP(a); IPCFreeARP(a);
@ -937,7 +937,7 @@ DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION
} }
if (IsTubeConnected(ipc->Sock->RecvTube) == false || IsTubeConnected(ipc->Sock->SendTube) == false || if (IsTubeConnected(ipc->Sock->RecvTube) == false || IsTubeConnected(ipc->Sock->SendTube) == false ||
(discon_poll_tube != NULL && IsTubeConnected(discon_poll_tube) == false)) (discon_poll_tube != NULL && IsTubeConnected(discon_poll_tube) == false))
{ {
// Session is disconnected // Session is disconnected
return NULL; return NULL;
@ -1007,7 +1007,7 @@ BUF *IPCBuildDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION_LIST *
Copy(((UCHAR *)(ph)) + sizeof(UDPV4_PSEUDO_HEADER), &dhcp, sizeof(dhcp)); Copy(((UCHAR *)(ph)) + sizeof(UDPV4_PSEUDO_HEADER), &dhcp, sizeof(dhcp));
Copy(((UCHAR *)(ph)) + sizeof(UDPV4_PSEUDO_HEADER) + sizeof(dhcp) + blank_size, &magic_number, sizeof(UINT)); Copy(((UCHAR *)(ph)) + sizeof(UDPV4_PSEUDO_HEADER) + sizeof(dhcp) + blank_size, &magic_number, sizeof(UINT));
Copy(((UCHAR *)(ph)) + sizeof(UDPV4_PSEUDO_HEADER) + sizeof(dhcp) + blank_size + sizeof(UINT), Copy(((UCHAR *)(ph)) + sizeof(UDPV4_PSEUDO_HEADER) + sizeof(dhcp) + blank_size + sizeof(UINT),
b->Buf, b->Size); b->Buf, b->Size);
// UDP Header // UDP Header
udp = (UDP_HEADER *)(((UCHAR *)ph) + 12); udp = (UDP_HEADER *)(((UCHAR *)ph) + 12);
@ -1223,7 +1223,7 @@ void IPCProcessArp(IPC *ipc, BLOCK *b)
void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address) void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address)
{ {
IPC_ARP *a; IPC_ARP *a;
// Validate arguments // Validate arguments
if (ipc == NULL || ip == NULL || IsValidUnicastIPAddress4(ip) == false || IsMacUnicast(mac_address) == false) if (ipc == NULL || ip == NULL || IsValidUnicastIPAddress4(ip) == false || IsMacUnicast(mac_address) == false)
{ {
return; return;
@ -1366,7 +1366,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now)
ok = true; ok = true;
} }
else if (ip_dst.addr[0] == 255 && ip_dst.addr[1] == 255 && else if (ip_dst.addr[0] == 255 && ip_dst.addr[1] == 255 &&
ip_dst.addr[2] == 255 && ip_dst.addr[3] == 255) ip_dst.addr[2] == 255 && ip_dst.addr[3] == 255)
{ {
ok = true; ok = true;
} }
@ -1404,13 +1404,13 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now)
} }
else if (protocol == MAC_PROTO_IPV6) else if (protocol == MAC_PROTO_IPV6)
{ {
PKT* p = ParsePacketUpToICMPv6(b->Buf, b->Size); PKT *p = ParsePacketUpToICMPv6(b->Buf, b->Size);
if (p != NULL) if (p != NULL)
{ {
IP ip_src, ip_dst; IP ip_src, ip_dst;
bool ndtProcessed = false; bool ndtProcessed = false;
UCHAR* data = Clone(p->L3.IPv6Header, p->L3.IPv6Header->PayloadLength + sizeof(IPV6_HEADER)); UCHAR *data = Clone(p->L3.IPv6Header, p->L3.IPv6Header->PayloadLength + sizeof(IPV6_HEADER));
IPv6AddrToIP(&ip_src, &p->IPv6HeaderPacketInfo.IPv6Header->SrcAddress); IPv6AddrToIP(&ip_src, &p->IPv6HeaderPacketInfo.IPv6Header->SrcAddress);
IPv6AddrToIP(&ip_dst, &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress); IPv6AddrToIP(&ip_dst, &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress);
@ -1602,7 +1602,7 @@ void IPCSendIPv4(IPC *ipc, void *data, UINT size)
UINT i; UINT i;
// Destination // Destination
for (i = 0;i < 6;i++) for (i = 0; i < 6; i++)
{ {
dest[i] = 0xff; dest[i] = 0xff;
} }
@ -1668,7 +1668,7 @@ void IPCFlushArpTableEx(IPC *ipc, UINT64 now)
now = Tick64(); now = Tick64();
} }
for (i = 0;i < LIST_NUM(ipc->ArpTable);i++) for (i = 0; i < LIST_NUM(ipc->ArpTable); i++)
{ {
IPC_ARP *a = LIST_DATA(ipc->ArpTable, i); IPC_ARP *a = LIST_DATA(ipc->ArpTable, i);
bool b = false; bool b = false;
@ -1695,7 +1695,7 @@ void IPCFlushArpTableEx(IPC *ipc, UINT64 now)
if (o != NULL) if (o != NULL)
{ {
for (i = 0;i < LIST_NUM(o);i++) for (i = 0; i < LIST_NUM(o); i++)
{ {
IPC_ARP *a = LIST_DATA(o, i); IPC_ARP *a = LIST_DATA(o, i);
@ -1759,7 +1759,7 @@ void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip)
arp.SrcIP = IPToUINT(&ipc->ClientIPAddress); arp.SrcIP = IPToUINT(&ipc->ClientIPAddress);
arp.TargetIP = IPToUINT(next_ip); arp.TargetIP = IPToUINT(next_ip);
for (i = 0;i < 6;i++) for (i = 0; i < 6; i++)
{ {
tmp[i] = 0xff; tmp[i] = 0xff;
} }
@ -1782,7 +1782,7 @@ void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip)
} }
// Search the ARP table // Search the ARP table
IPC_ARP *IPCSearchArpTable(LIST* arpTable, IP *ip) IPC_ARP *IPCSearchArpTable(LIST *arpTable, IP *ip)
{ {
IPC_ARP t; IPC_ARP t;
IPC_ARP *a; IPC_ARP *a;
@ -1939,19 +1939,22 @@ BLOCK *IPCRecvL2(IPC *ipc)
// IPv6 stuff // IPv6 stuff
// Memory management // Memory management
void IPCIPv6Init(IPC* ipc) void IPCIPv6Init(IPC *ipc)
{ {
ipc->IPv6ReceivedQueue = NewQueue(); ipc->IPv6ReceivedQueue = NewQueue();
// The NDT is basically the same as ARP Table with some slight adjustments // The NDT is basically the same as ARP Table with some slight adjustments
ipc->IPv6NeighborTable = NewList(IPCCmpArpTable); ipc->IPv6NeighborTable = NewList(IPCCmpArpTable);
ipc->IPv6RouterAdvs = NewList(NULL); ipc->IPv6RouterAdvs = NewList(NULL);
ipc->IPv6ClientEUI = 0;
ipc->IPv6ServerEUI = 0;
} }
void IPCIPv6Free(IPC* ipc) void IPCIPv6Free(IPC *ipc)
{ {
UINT i; UINT i;
for (i = 0; i < LIST_NUM(ipc->IPv6NeighborTable); i++) for (i = 0; i < LIST_NUM(ipc->IPv6NeighborTable); i++)
{ {
IPC_ARP* a = LIST_DATA(ipc->IPv6NeighborTable, i); IPC_ARP *a = LIST_DATA(ipc->IPv6NeighborTable, i);
IPCFreeARP(a); IPCFreeARP(a);
} }
@ -1959,7 +1962,7 @@ void IPCIPv6Free(IPC* ipc)
for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++)
{ {
IPC_IPV6_ROUTER_ADVERTISEMENT* ra = LIST_DATA(ipc->IPv6RouterAdvs, i); IPC_IPV6_ROUTER_ADVERTISEMENT *ra = LIST_DATA(ipc->IPv6RouterAdvs, i);
Free(ra); Free(ra);
} }
@ -1967,7 +1970,7 @@ void IPCIPv6Free(IPC* ipc)
while (true) while (true)
{ {
BLOCK* b = GetNext(ipc->IPv6ReceivedQueue); BLOCK *b = GetNext(ipc->IPv6ReceivedQueue);
if (b == NULL) if (b == NULL)
{ {
break; break;
@ -1980,17 +1983,17 @@ void IPCIPv6Free(IPC* ipc)
} }
// NDT // NDT
void IPCIPv6AssociateOnNDT(IPC* ipc, IP* ip, UCHAR* mac_address) void IPCIPv6AssociateOnNDT(IPC *ipc, IP *ip, UCHAR *mac_address)
{ {
IPCIPv6AssociateOnNDTEx(ipc, ip, mac_address, false); IPCIPv6AssociateOnNDTEx(ipc, ip, mac_address, false);
} }
void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighborAdv) void IPCIPv6AssociateOnNDTEx(IPC *ipc, IP *ip, UCHAR *mac_address, bool isNeighborAdv)
{ {
IPC_ARP* a; IPC_ARP *a;
UINT addrType = 0; UINT addrType = 0;
if (ipc == NULL || ip == NULL || if (ipc == NULL || ip == NULL ||
IsValidUnicastIPAddress6(ip) == false || IsValidUnicastIPAddress6(ip) == false ||
IsMacUnicast(mac_address) == false) IsMacUnicast(mac_address) == false)
{ {
return; return;
} }
@ -1998,7 +2001,7 @@ void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighb
addrType = GetIPAddrType6(ip); addrType = GetIPAddrType6(ip);
if (addrType != IPV6_ADDR_LOCAL_UNICAST && if (addrType != IPV6_ADDR_LOCAL_UNICAST &&
addrType != IPV6_ADDR_GLOBAL_UNICAST) addrType != IPV6_ADDR_GLOBAL_UNICAST)
{ {
return; return;
} }
@ -2027,14 +2030,14 @@ void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighb
else else
{ {
Copy(a->MacAddress, mac_address, 6); Copy(a->MacAddress, mac_address, 6);
if (a->Resolved == false) if (a->Resolved == false)
{ {
a->Resolved = true; a->Resolved = true;
a->GiveupTime = 0; a->GiveupTime = 0;
while (true) while (true)
{ {
BLOCK* b = GetNext(a->PacketQueue); BLOCK *b = GetNext(a->PacketQueue);
if (b == NULL) if (b == NULL)
{ {
@ -2051,14 +2054,14 @@ void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighb
} }
} }
void IPCIPv6FlushNDT(IPC* ipc) void IPCIPv6FlushNDT(IPC *ipc)
{ {
IPCIPv6FlushNDTEx(ipc, 0); IPCIPv6FlushNDTEx(ipc, 0);
} }
void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now) void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now)
{ {
UINT i; UINT i;
LIST* o = NULL; LIST *o = NULL;
// Validate arguments // Validate arguments
if (ipc == NULL) if (ipc == NULL)
{ {
@ -2071,7 +2074,7 @@ void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now)
for (i = 0; i < LIST_NUM(ipc->IPv6NeighborTable); i++) for (i = 0; i < LIST_NUM(ipc->IPv6NeighborTable); i++)
{ {
IPC_ARP* a = LIST_DATA(ipc->IPv6NeighborTable, i); IPC_ARP *a = LIST_DATA(ipc->IPv6NeighborTable, i);
bool b = false; bool b = false;
if (a->Resolved && a->ExpireTime <= now) if (a->Resolved && a->ExpireTime <= now)
@ -2099,7 +2102,7 @@ void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now)
{ {
for (i = 0; i < LIST_NUM(o); i++) for (i = 0; i < LIST_NUM(o); i++)
{ {
IPC_ARP* a = LIST_DATA(o, i); IPC_ARP *a = LIST_DATA(o, i);
IPCFreeARP(a); IPCFreeARP(a);
@ -2110,14 +2113,24 @@ void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now)
} }
} }
bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, IP *addr)
{
HUB t, *h;
IP_TABLE_ENTRY t, *e;
t.Name = ipc->HubName;
h = Search(ipc->Cedar->HubList, &t);
//h->IpTable
}
// RA // RA
void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* macAddress, IP* ip) void IPCIPv6AddRouterPrefix(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip)
{ {
UINT i; UINT i;
bool foundPrefix = false; bool foundPrefix = false;
for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++)
{ {
IPC_IPV6_ROUTER_ADVERTISEMENT* existingRA = LIST_DATA(ipc->IPv6RouterAdvs, i); IPC_IPV6_ROUTER_ADVERTISEMENT *existingRA = LIST_DATA(ipc->IPv6RouterAdvs, i);
if (Cmp(&recvPrefix->Prefix->Prefix, &existingRA->RoutedPrefix.ipv6_addr, sizeof(IPV6_ADDR)) == 0) if (Cmp(&recvPrefix->Prefix->Prefix, &existingRA->RoutedPrefix.ipv6_addr, sizeof(IPV6_ADDR)) == 0)
{ {
foundPrefix = true; foundPrefix = true;
@ -2127,7 +2140,7 @@ void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* mac
if (!foundPrefix) if (!foundPrefix)
{ {
IPC_IPV6_ROUTER_ADVERTISEMENT* newRA = Malloc(sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); IPC_IPV6_ROUTER_ADVERTISEMENT *newRA = Malloc(sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT));
IPv6AddrToIP(&newRA->RoutedPrefix, &recvPrefix->Prefix->Prefix); IPv6AddrToIP(&newRA->RoutedPrefix, &recvPrefix->Prefix->Prefix);
IntToSubnetMask6(&newRA->RoutedMask, recvPrefix->Prefix->SubnetLength); IntToSubnetMask6(&newRA->RoutedMask, recvPrefix->Prefix->SubnetLength);
CopyIP(&newRA->RouterAddress, ip); CopyIP(&newRA->RouterAddress, ip);
@ -2137,14 +2150,14 @@ void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* mac
} }
} }
bool IPCIPv6CheckUnicastFromRouterPrefix(IPC* ipc, IP* ip, IPC_IPV6_ROUTER_ADVERTISEMENT* matchedRA) bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVERTISEMENT *matchedRA)
{ {
UINT i; UINT i;
IPC_IPV6_ROUTER_ADVERTISEMENT* matchingRA = NULL; IPC_IPV6_ROUTER_ADVERTISEMENT *matchingRA = NULL;
bool isInPrefix = false; bool isInPrefix = false;
for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++)
{ {
IPC_IPV6_ROUTER_ADVERTISEMENT* ra = LIST_DATA(ipc->IPv6RouterAdvs, i); IPC_IPV6_ROUTER_ADVERTISEMENT *ra = LIST_DATA(ipc->IPv6RouterAdvs, i);
isInPrefix = IsInSameNetwork6(ip, &ra->RoutedPrefix, &ra->RoutedMask); isInPrefix = IsInSameNetwork6(ip, &ra->RoutedPrefix, &ra->RoutedMask);
if (isInPrefix) if (isInPrefix)
{ {
@ -2162,7 +2175,7 @@ bool IPCIPv6CheckUnicastFromRouterPrefix(IPC* ipc, IP* ip, IPC_IPV6_ROUTER_ADVER
} }
// Send router solicitation and then eventually populate the info from Router Advertisements // Send router solicitation and then eventually populate the info from Router Advertisements
void IPCIPv6SendRouterSolicitation(IPC* ipc) void IPCIPv6SendRouterSolicitation(IPC *ipc)
{ {
IP senderIP; IP senderIP;
IP destIP; IP destIP;
@ -2170,7 +2183,7 @@ void IPCIPv6SendRouterSolicitation(IPC* ipc)
IPV6_ADDR linkLocal; IPV6_ADDR linkLocal;
BUF *packet; BUF *packet;
Zero(&linkLocal, sizeof(IPV6_ADDR)); Zero(&linkLocal, sizeof(IPV6_ADDR));
// Generate link local from client's EUI // Generate link local from client's EUI
linkLocal.Value[0] = 0xFE; linkLocal.Value[0] = 0xFE;
linkLocal.Value[1] = 0x80; linkLocal.Value[1] = 0x80;
@ -2202,12 +2215,19 @@ void IPCIPv6SendRouterSolicitation(IPC* ipc)
// The processing should populate the received RAs by itself // The processing should populate the received RAs by itself
IPCProcessL3Events(ipc); IPCProcessL3Events(ipc);
} }
// Populating the IPv6 Server EUI for IPV6CP
if (LIST_NUM(ipc->IPv6RouterAdvs) > 0)
{
IPC_IPV6_ROUTER_ADVERTISEMENT *ra = LIST_DATA(ipc->IPv6RouterAdvs, 0);
ipc->IPv6ServerEUI = READ_UINT64(&ra->RouterAddress.ipv6_addr[8]);
}
} }
// Data flow // Data flow
BLOCK* IPCIPv6Recv(IPC* ipc) BLOCK *IPCIPv6Recv(IPC *ipc)
{ {
BLOCK* b; BLOCK *b;
// Validate arguments // Validate arguments
if (ipc == NULL) if (ipc == NULL)
{ {
@ -2219,13 +2239,13 @@ BLOCK* IPCIPv6Recv(IPC* ipc)
return b; return b;
} }
void IPCIPv6Send(IPC* ipc, void* data, UINT size) void IPCIPv6Send(IPC *ipc, void *data, UINT size)
{ {
IP destAddr; IP destAddr;
UINT ipv6Type; UINT ipv6Type;
UCHAR destMac[6]; UCHAR destMac[6];
IPV6_HEADER* header = data; IPV6_HEADER *header = data;
IPv6AddrToIP(&destAddr, &header->DestAddress); IPv6AddrToIP(&destAddr, &header->DestAddress);
if (IsValidUnicastIPAddress6(&destAddr)) if (IsValidUnicastIPAddress6(&destAddr))
@ -2254,7 +2274,7 @@ void IPCIPv6Send(IPC* ipc, void* data, UINT size)
} }
} }
void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac_addr) void IPCIPv6SendWithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr)
{ {
UCHAR tmp[1514]; UCHAR tmp[1514];
// Validate arguments // Validate arguments
@ -2279,12 +2299,12 @@ void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac
IPCSendL2(ipc, tmp, size + 14); IPCSendL2(ipc, tmp, size + 14);
} }
void IPCIPv6SendUnicast(IPC* ipc, void* data, UINT size, IP* next_ip) void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip)
{ {
IPC_ARP* ndtMatch; IPC_ARP *ndtMatch;
UCHAR* destMac = NULL; UCHAR *destMac = NULL;
IPC_IPV6_ROUTER_ADVERTISEMENT ra; IPC_IPV6_ROUTER_ADVERTISEMENT ra;
IPV6_HEADER* header = data; IPV6_HEADER *header = data;
IP srcIp; IP srcIp;
bool isLocal = false; bool isLocal = false;
// First we need to understand if it is a local packet or we should route it through the router // First we need to understand if it is a local packet or we should route it through the router
@ -2346,11 +2366,11 @@ void IPCIPv6SendUnicast(IPC* ipc, void* data, UINT size, IP* next_ip)
/// TODO: check if we need to manage NDT manually from here or the client will /// TODO: check if we need to manage NDT manually from here or the client will
/// TODO: send Neighbor Solicitations by itself and we just proxy them /// TODO: send Neighbor Solicitations by itself and we just proxy them
CHAR tmp[MAX_SIZE]; CHAR tmp[MAX_SIZE];
BLOCK* blk = NewBlock(data, size, 0); BLOCK *blk = NewBlock(data, size, 0);
InsertQueue(ndtMatch->PacketQueue, blk); InsertQueue(ndtMatch->PacketQueue, blk);
IPToStr6(tmp, MAX_SIZE, next_ip); IPToStr6(tmp, MAX_SIZE, next_ip);
Debug("We can't send the packet because we don't have IP %s in NDT! Need to send Neighbor Solicitation first... Saving for later send.\n", tmp); Debug("We can't send the packet because we don't have IP %s in NDT! Need to send Neighbor Solicitation first... Saving for later send.\n", tmp);
return; return;
} }
destMac = ndtMatch->MacAddress; destMac = ndtMatch->MacAddress;

43
src/Cedar/IPC.h
View File

@ -125,9 +125,9 @@ struct IPC
UINT Layer; UINT Layer;
// IPv6 stuff // IPv6 stuff
QUEUE* IPv6ReceivedQueue; // IPv6 reception queue QUEUE *IPv6ReceivedQueue; // IPv6 reception queue
LIST* IPv6NeighborTable; // Neighbor Discovery Table LIST *IPv6NeighborTable; // Neighbor Discovery Table
LIST* IPv6RouterAdvs; // Router offered prefixes LIST *IPv6RouterAdvs; // Router offered prefixes
UINT64 IPv6ClientEUI; // The EUI of the client (for the SLAAC autoconf) UINT64 IPv6ClientEUI; // The EUI of the client (for the SLAAC autoconf)
UINT64 IPv6ServerEUI; // The EUI of the server (from the RA discovery) UINT64 IPv6ServerEUI; // The EUI of the server (from the RA discovery)
}; };
@ -152,10 +152,10 @@ struct IPC_IPV6_ROUTER_ADVERTISEMENT
}; };
IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char *username, char *password, IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char *username, char *password,
UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port, UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port,
char *client_hostname, char *crypt_name, char *client_hostname, char *crypt_name,
bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate, bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate,
UINT layer); UINT layer);
IPC *NewIPCByParam(CEDAR *cedar, IPC_PARAM *param, UINT *error_code); IPC *NewIPCByParam(CEDAR *cedar, IPC_PARAM *param, UINT *error_code);
IPC *NewIPCBySock(CEDAR *cedar, SOCK *s, void *mac_address); IPC *NewIPCBySock(CEDAR *cedar, SOCK *s, void *mac_address);
void FreeIPC(IPC *ipc); void FreeIPC(IPC *ipc);
@ -173,7 +173,7 @@ IPC_ARP *IPCNewARP(IP *ip, UCHAR *mac_address);
void IPCFreeARP(IPC_ARP *a); void IPCFreeARP(IPC_ARP *a);
int IPCCmpArpTable(void *p1, void *p2); int IPCCmpArpTable(void *p1, void *p2);
void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip); void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip);
IPC_ARP *IPCSearchArpTable(LIST* arpTable, IP *ip); IPC_ARP *IPCSearchArpTable(LIST *arpTable, IP *ip);
void IPCSendIPv4WithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr); void IPCSendIPv4WithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr);
void IPCFlushArpTable(IPC *ipc); void IPCFlushArpTable(IPC *ipc);
void IPCFlushArpTableEx(IPC *ipc, UINT64 now); void IPCFlushArpTableEx(IPC *ipc, UINT64 now);
@ -195,22 +195,23 @@ void FreeIPCAsync(IPC_ASYNC *a);
// IPv6 stuff // IPv6 stuff
// Memory management // Memory management
void IPCIPv6Init(IPC* ipc); void IPCIPv6Init(IPC *ipc);
void IPCIPv6Free(IPC* ipc); void IPCIPv6Free(IPC *ipc);
// NDT // NDT
void IPCIPv6AssociateOnNDT(IPC* ipc, IP* ip, UCHAR* mac_address); void IPCIPv6AssociateOnNDT(IPC *ipc, IP *ip, UCHAR *mac_address);
void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighborAdv); void IPCIPv6AssociateOnNDTEx(IPC *ipc, IP *ip, UCHAR *mac_address, bool isNeighborAdv);
void IPCIPv6FlushNDT(IPC* ipc); void IPCIPv6FlushNDT(IPC *ipc);
void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now); void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now);
bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, IP *addr);
// RA // RA
void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* macAddress, IP* ip); void IPCIPv6AddRouterPrefix(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip);
bool IPCIPv6CheckUnicastFromRouterPrefix(IPC* ipc, IP* ip, IPC_IPV6_ROUTER_ADVERTISEMENT* matchedRA); bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVERTISEMENT *matchedRA);
void IPCIPv6SendRouterSolicitation(IPC* ipc); void IPCIPv6SendRouterSolicitation(IPC *ipc);
// Data flow // Data flow
BLOCK* IPCIPv6Recv(IPC* ipc); BLOCK *IPCIPv6Recv(IPC *ipc);
void IPCIPv6Send(IPC* ipc, void* data, UINT size); void IPCIPv6Send(IPC *ipc, void *data, UINT size);
void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac_addr); void IPCIPv6SendWithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr);
void IPCIPv6SendUnicast(IPC* ipc, void* data, UINT size, IP* next_ip); void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip);
bool ParseAndExtractMsChapV2InfoFromPassword(IPC_MSCHAP_V2_AUTHINFO *d, char *password); bool ParseAndExtractMsChapV2InfoFromPassword(IPC_MSCHAP_V2_AUTHINFO *d, char *password);

130
src/Cedar/Proto_PPP.c
View File

@ -53,7 +53,7 @@ void PPPThread(THREAD *thread, void *param)
IPToStr(ipstr1, sizeof(ipstr1), &p->ClientIP); IPToStr(ipstr1, sizeof(ipstr1), &p->ClientIP);
IPToStr(ipstr2, sizeof(ipstr2), &p->ServerIP); IPToStr(ipstr2, sizeof(ipstr2), &p->ServerIP);
PPPLog(p, "LP_CONNECTED", p->Postfix, ipstr1, p->ClientHostname, p->ClientPort, ipstr2, p->ServerPort, PPPLog(p, "LP_CONNECTED", p->Postfix, ipstr1, p->ClientHostname, p->ClientPort, ipstr2, p->ServerPort,
p->ClientSoftwareName, p->AdjustMss); p->ClientSoftwareName, p->AdjustMss);
// We need that so we don't time out on connection immediately // We need that so we don't time out on connection immediately
p->LastRecvTime = Tick64(); p->LastRecvTime = Tick64();
@ -148,7 +148,7 @@ void PPPThread(THREAD *thread, void *param)
if (!receivedPacketProcessed && p->CurrentPacket != NULL && p->CurrentPacket->IsControl && PPP_CODE_IS_RESPONSE(p->CurrentPacket->Protocol, p->CurrentPacket->Lcp->Code) && !PPP_STATUS_IS_UNAVAILABLE(p->PPPStatus)) if (!receivedPacketProcessed && p->CurrentPacket != NULL && p->CurrentPacket->IsControl && PPP_CODE_IS_RESPONSE(p->CurrentPacket->Protocol, p->CurrentPacket->Lcp->Code) && !PPP_STATUS_IS_UNAVAILABLE(p->PPPStatus))
{ {
PPP_PACKET *request = NULL; PPP_PACKET *request = NULL;
// Removing from resend list // Removing from resend list
for (i = 0; i < LIST_NUM(p->SentReqPacketList); i++) for (i = 0; i < LIST_NUM(p->SentReqPacketList); i++)
{ {
PPP_REQUEST_RESEND *t = LIST_DATA(p->SentReqPacketList, i); PPP_REQUEST_RESEND *t = LIST_DATA(p->SentReqPacketList, i);
@ -275,14 +275,14 @@ void PPPThread(THREAD *thread, void *param)
// We got to start CHAP when we got no LCP packets from the client on previous iteration // We got to start CHAP when we got no LCP packets from the client on previous iteration
// which means we parsed all the client requests and responses // which means we parsed all the client requests and responses
Debug("Starting PPP Authentication phase MS-CHAP v2\n"); Debug("Starting PPP Authentication phase MS-CHAP v2\n");
lcp = BuildMSCHAP2ChallengePacket(p); lcp = BuildMSCHAP2ChallengePacket(p);
if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_CHAP, lcp)) if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_CHAP, lcp))
{ {
PPPSetStatus(p, PPP_STATUS_FAIL); PPPSetStatus(p, PPP_STATUS_FAIL);
WHERE; WHERE;
} }
PPPSetStatus(p, PPP_STATUS_AUTHENTICATING); PPPSetStatus(p, PPP_STATUS_AUTHENTICATING);
} }
@ -334,7 +334,7 @@ void PPPThread(THREAD *thread, void *param)
} }
IPCProcessL3Events(p->Ipc); IPCProcessL3Events(p->Ipc);
timeBeforeLoop = Tick64(); timeBeforeLoop = Tick64();
while (true) while (true)
@ -398,7 +398,7 @@ void PPPThread(THREAD *thread, void *param)
} }
tubes[0] = p->TubeRecv; tubes[0] = p->TubeRecv;
if (p->PPPStatus == PPP_STATUS_NETWORK_LAYER && p->Ipc != NULL && IsIPCConnected(p->Ipc)) if (p->PPPStatus == PPP_STATUS_NETWORK_LAYER && p->Ipc != NULL && IsIPCConnected(p->Ipc))
{ {
r = GetNextIntervalForInterrupt(p->Ipc->Interrupt); r = GetNextIntervalForInterrupt(p->Ipc->Interrupt);
@ -434,7 +434,7 @@ void PPPThread(THREAD *thread, void *param)
// Maximum PPP session time of the user reached inspection // Maximum PPP session time of the user reached inspection
if (p->UserConnectionTick != 0 && p->UserConnectionTimeout != 0 && if (p->UserConnectionTick != 0 && p->UserConnectionTimeout != 0 &&
p->UserConnectionTick + p->UserConnectionTimeout <= now) p->UserConnectionTick + p->UserConnectionTimeout <= now)
{ {
// User connection time-out occurs // User connection time-out occurs
PPPLog(p, "LP_USER_TIMEOUT"); PPPLog(p, "LP_USER_TIMEOUT");
@ -864,7 +864,7 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req
WHERE; WHERE;
return false; return false;
} }
if (opt->DataSize == sizeof(USHORT) && *((USHORT*)(opt->Data)) == Endian16(PPP_LCP_AUTH_EAP)) if (opt->DataSize == sizeof(USHORT) && *((USHORT *)(opt->Data)) == Endian16(PPP_LCP_AUTH_EAP))
{ {
// Try to request MS-CHAPv2 then // Try to request MS-CHAPv2 then
if (!isAccepted) if (!isAccepted)
@ -877,7 +877,7 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req
ms_chap_v2_code[2] = PPP_CHAP_ALG_MS_CHAP_V2; ms_chap_v2_code[2] = PPP_CHAP_ALG_MS_CHAP_V2;
Copy(&offer, ms_chap_v2_code, sizeof(ms_chap_v2_code)); Copy(&offer, ms_chap_v2_code, sizeof(ms_chap_v2_code));
Debug("NACK proto with code = 0x%x, cypher = 0x%x, offered cypher = 0x%x\n", pp->Lcp->Code, *((USHORT*)(opt->Data)), offer); Debug("NACK proto with code = 0x%x, cypher = 0x%x, offered cypher = 0x%x\n", pp->Lcp->Code, *((USHORT *)(opt->Data)), offer);
Debug("Request MSCHAPv2\n"); Debug("Request MSCHAPv2\n");
Add(c->OptionList, NewPPPOption(PPP_LCP_OPTION_AUTH, &ms_chap_v2_code, sizeof(ms_chap_v2_code))); Add(c->OptionList, NewPPPOption(PPP_LCP_OPTION_AUTH, &ms_chap_v2_code, sizeof(ms_chap_v2_code)));
if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_LCP, c)) if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_LCP, c))
@ -903,7 +903,7 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req
PPP_LCP *c = NewPPPLCP(PPP_LCP_CODE_REQ, 0); PPP_LCP *c = NewPPPLCP(PPP_LCP_CODE_REQ, 0);
USHORT proto = Endian16(PPP_LCP_AUTH_PAP); USHORT proto = Endian16(PPP_LCP_AUTH_PAP);
Copy(&offer, t->Data, t->DataSize > sizeof(UINT64) ? sizeof(UINT64) : t->DataSize); Copy(&offer, t->Data, t->DataSize > sizeof(UINT64) ? sizeof(UINT64) : t->DataSize);
Debug("NACK proto with code = 0x%x, cypher = 0x%x, offered cypher = 0x%x\n", pp->Lcp->Code, *((USHORT*)(opt->Data)), offer); Debug("NACK proto with code = 0x%x, cypher = 0x%x, offered cypher = 0x%x\n", pp->Lcp->Code, *((USHORT *)(opt->Data)), offer);
Debug("Request PAP\n"); Debug("Request PAP\n");
Add(c->OptionList, NewPPPOption(PPP_LCP_OPTION_AUTH, &proto, sizeof(USHORT))); Add(c->OptionList, NewPPPOption(PPP_LCP_OPTION_AUTH, &proto, sizeof(USHORT)));
if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_LCP, c)) if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_LCP, c))
@ -919,16 +919,16 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req
Debug("Setting BEFORE_AUTH from ACK on LCP response parse on CHAP accept\n"); Debug("Setting BEFORE_AUTH from ACK on LCP response parse on CHAP accept\n");
PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH); PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH);
} }
} }
else if (opt->DataSize == sizeof(USHORT) && *((USHORT*)(opt->Data)) == Endian16(PPP_LCP_AUTH_PAP)) else if (opt->DataSize == sizeof(USHORT) && *((USHORT *)(opt->Data)) == Endian16(PPP_LCP_AUTH_PAP))
{ {
// We couldn't agree on auth proto, failing connection // We couldn't agree on auth proto, failing connection
if (!isAccepted) if (!isAccepted)
{ {
UINT64 offer = 0; UINT64 offer = 0;
Copy(&offer, t->Data, t->DataSize > sizeof(UINT64) ? sizeof(UINT64) : t->DataSize); Copy(&offer, t->Data, t->DataSize > sizeof(UINT64) ? sizeof(UINT64) : t->DataSize);
Debug("NACK proto with code = 0x%x, cypher = 0x%x, offered cypher = 0x%x\n", pp->Lcp->Code, *((USHORT*)(opt->Data)), offer); Debug("NACK proto with code = 0x%x, cypher = 0x%x, offered cypher = 0x%x\n", pp->Lcp->Code, *((USHORT *)(opt->Data)), offer);
Debug("Couldn't agree on auth protocol!\n"); Debug("Couldn't agree on auth protocol!\n");
PPPLog(p, "LP_PAP_MSCHAPV2_REJECTED"); PPPLog(p, "LP_PAP_MSCHAPV2_REJECTED");
PPPSetStatus(p, PPP_STATUS_FAIL); PPPSetStatus(p, PPP_STATUS_FAIL);
@ -994,7 +994,7 @@ bool PPPProcessCHAPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re
BinToStr(hex, sizeof(hex), p->MsChapV2_ServerResponse, 20); BinToStr(hex, sizeof(hex), p->MsChapV2_ServerResponse, 20);
Format(ret_str, sizeof(ret_str), Format(ret_str, sizeof(ret_str),
"S=%s", hex); "S=%s", hex);
WriteBuf(lcp_ret_data, ret_str, StrLen(ret_str)); WriteBuf(lcp_ret_data, ret_str, StrLen(ret_str));
@ -1032,7 +1032,7 @@ bool PPPProcessCHAPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re
BinToStr(hex, sizeof(hex), p->MsChapV2_ServerChallenge, 16); BinToStr(hex, sizeof(hex), p->MsChapV2_ServerChallenge, 16);
Format(ret_str, sizeof(ret_str), Format(ret_str, sizeof(ret_str),
"E=%u R=0 C=%s V=3", p->MsChapV2_ErrorCode, hex); "E=%u R=0 C=%s V=3", p->MsChapV2_ErrorCode, hex);
WriteBuf(lcp_ret_data, ret_str, StrLen(ret_str)); WriteBuf(lcp_ret_data, ret_str, StrLen(ret_str));
@ -1086,11 +1086,11 @@ bool PPPProcessIPCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re
PPPRejectUnsupportedPacketEx(p, pp, true); PPPRejectUnsupportedPacketEx(p, pp, true);
return false; return false;
} }
// We're dealing either with ACK or NACK // We're dealing either with ACK or NACK
addr = IPToUINT(&addrStruct); addr = IPToUINT(&addrStruct);
IPToStr(addrStr, MAX_SIZE, &addrStruct); IPToStr(addrStr, MAX_SIZE, &addrStruct);
if (isAccepted) if (isAccepted)
{ {
Debug("Accepted server IP address of %s\n", addrStr); Debug("Accepted server IP address of %s\n", addrStr);
@ -1156,7 +1156,7 @@ bool PPPProcessEAPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req
PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH); PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH);
break; break;
case PPP_EAP_TYPE_NOTIFICATION: case PPP_EAP_TYPE_NOTIFICATION:
// Basically this is just an acknoweldgment that the notification was accepted by the client. Nothing to do here... // Basically this is just an acknoweldgment that the notification was accepted by the client. Nothing to do here...
break; break;
case PPP_EAP_TYPE_NAK: case PPP_EAP_TYPE_NAK:
/// TODO: implement alternative EAP protocol selection based on received NAK /// TODO: implement alternative EAP protocol selection based on received NAK
@ -1265,12 +1265,12 @@ bool PPPProcessLCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
{ {
case PPP_LCP_OPTION_AUTH: case PPP_LCP_OPTION_AUTH:
t->IsSupported = true; t->IsSupported = true;
if (t->DataSize == sizeof(USHORT) && *((USHORT*)t->Data) == PPP_LCP_AUTH_EAP && p->AuthProtocol == PPP_UNSPECIFIED) if (t->DataSize == sizeof(USHORT) && *((USHORT *)t->Data) == PPP_LCP_AUTH_EAP && p->AuthProtocol == PPP_UNSPECIFIED)
{ {
t->IsAccepted = true; t->IsAccepted = true;
NegotiatedAuthProto = PPP_PROTOCOL_EAP; NegotiatedAuthProto = PPP_PROTOCOL_EAP;
} }
else if (t->DataSize == sizeof(USHORT) && *((USHORT*)t->Data) == PPP_LCP_AUTH_PAP && p->AuthProtocol == PPP_UNSPECIFIED) else if (t->DataSize == sizeof(USHORT) && *((USHORT *)t->Data) == PPP_LCP_AUTH_PAP && p->AuthProtocol == PPP_UNSPECIFIED)
{ {
t->IsAccepted = true; t->IsAccepted = true;
NegotiatedAuthProto = PPP_PROTOCOL_PAP; NegotiatedAuthProto = PPP_PROTOCOL_PAP;
@ -1338,7 +1338,7 @@ bool PPPProcessLCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
{ {
return false; return false;
} }
if (NegotiatedAuthProto != PPP_UNSPECIFIED) if (NegotiatedAuthProto != PPP_UNSPECIFIED)
{ {
if (p->AuthProtocol == PPP_UNSPECIFIED) if (p->AuthProtocol == PPP_UNSPECIFIED)
@ -1346,7 +1346,7 @@ bool PPPProcessLCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
p->AuthProtocol = NegotiatedAuthProto; p->AuthProtocol = NegotiatedAuthProto;
PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH); PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH);
Debug("Setting BEFORE_AUTH from REQ on LCP request parse\n"); Debug("Setting BEFORE_AUTH from REQ on LCP request parse\n");
} }
} }
if (NegotiatedMRU != PPP_UNSPECIFIED) if (NegotiatedMRU != PPP_UNSPECIFIED)
{ {
@ -1362,9 +1362,9 @@ bool PPPProcessPAPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
{ {
PPP_LCP *lcp = NewPPPLCP(PPP_PAP_CODE_NAK, pp->Lcp->Id); PPP_LCP *lcp = NewPPPLCP(PPP_PAP_CODE_NAK, pp->Lcp->Id);
PPP_PACKET *ret = ZeroMalloc(sizeof(PPP_PACKET)); PPP_PACKET *ret = ZeroMalloc(sizeof(PPP_PACKET));
Debug("Got a PAP request before we're ready for AUTH procedure!\n"); Debug("Got a PAP request before we're ready for AUTH procedure!\n");
ret->IsControl = true; ret->IsControl = true;
ret->Protocol = PPP_PROTOCOL_PAP; ret->Protocol = PPP_PROTOCOL_PAP;
ret->Lcp = lcp; ret->Lcp = lcp;
@ -1453,9 +1453,9 @@ bool PPPProcessPAPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
UINT error_code; UINT error_code;
ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, hub, id, password, ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, hub, id, password,
&error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort,
p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, NULL, p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, NULL,
IPC_LAYER_3); IPC_LAYER_3);
if (ipc != NULL) if (ipc != NULL)
{ {
@ -1637,9 +1637,9 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
IPToStr32(wins2_str, sizeof(wins2_str), cao.WinsServer2); IPToStr32(wins2_str, sizeof(wins2_str), cao.WinsServer2);
PPPLog(p, "LP_DHCP_INFORM_OK", PPPLog(p, "LP_DHCP_INFORM_OK",
subnet_str, defgw_str, cao.DomainName, subnet_str, defgw_str, cao.DomainName,
dns1_str, dns2_str, wins1_str, wins2_str, dns1_str, dns2_str, wins1_str, wins2_str,
server_ip_str); server_ip_str);
} }
} }
else else
@ -1690,8 +1690,8 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
t = 1; t = 1;
} }
p->DhcpRenewInterval = (UINT64)t * (UINT64)1000; p->DhcpRenewInterval = (UINT64)t * (UINT64)1000;
p->DhcpNextRenewTime = Tick64() + p->DhcpRenewInterval; p->DhcpNextRenewTime = Tick64() + p->DhcpRenewInterval;
if (true) if (true)
{ {
@ -1710,9 +1710,9 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
IPToStr32(wins2_str, sizeof(wins2_str), cao.WinsServer2); IPToStr32(wins2_str, sizeof(wins2_str), cao.WinsServer2);
PPPLog(p, "LP_DHCP_REQUEST_OK", PPPLog(p, "LP_DHCP_REQUEST_OK",
client_ip_str, subnet_str, defgw_str, cao.DomainName, client_ip_str, subnet_str, defgw_str, cao.DomainName,
dns1_str, dns2_str, wins1_str, wins2_str, dns1_str, dns2_str, wins1_str, wins2_str,
server_ip_str, cao.LeaseTime); server_ip_str, cao.LeaseTime);
} }
} }
else else
@ -1728,7 +1728,7 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
// If we already have a configured IP data - send it along // If we already have a configured IP data - send it along
if (IsValidUnicastIPAddressUINT4(p->ClientAddressOption.ClientAddress) && if (IsValidUnicastIPAddressUINT4(p->ClientAddressOption.ClientAddress) &&
p->ClientAddressOption.SubnetMask != 0 && ok) p->ClientAddressOption.SubnetMask != 0 && ok)
{ {
// Success to determine the address // Success to determine the address
UINTToIP(&subnet, p->ClientAddressOption.SubnetMask); UINTToIP(&subnet, p->ClientAddressOption.SubnetMask);
@ -1760,7 +1760,7 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
IPToStr(wins2_str, sizeof(wins2_str), &res.WinsServer2); IPToStr(wins2_str, sizeof(wins2_str), &res.WinsServer2);
PPPLog(p, "LP_SET_IPV4_PARAM", client_ip_str, subnet_str, PPPLog(p, "LP_SET_IPV4_PARAM", client_ip_str, subnet_str,
defgw_str, dns1_str, dns2_str, wins1_str, wins2_str); defgw_str, dns1_str, dns2_str, wins1_str, wins2_str);
} }
/*// Backporting static configuration received from client - let him use whatever he wants, /*// Backporting static configuration received from client - let him use whatever he wants,
@ -1808,7 +1808,7 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp)
PPPSetIPOptionToLCP(&res, pp->Lcp, true); PPPSetIPOptionToLCP(&res, pp->Lcp, true);
} }
if (PPPRejectLCPOptionsEx(p, pp, processed)) if (PPPRejectLCPOptionsEx(p, pp, processed))
{ {
Debug("Rejected IPCP options ID = 0x%x\n", pp->Lcp->Id); Debug("Rejected IPCP options ID = 0x%x\n", pp->Lcp->Id);
@ -2186,7 +2186,7 @@ PPP_PACKET *PPPGetNextPacket(PPP_SESSION *p)
} }
ret = PPPRecvPacket(p, true); ret = PPPRecvPacket(p, true);
if (ret != NULL && ret->IsControl && ret->Lcp != NULL) if (ret != NULL && ret->IsControl && ret->Lcp != NULL)
{ {
PPP_DELAYED_PACKET *firstRelated = NULL; PPP_DELAYED_PACKET *firstRelated = NULL;
@ -2308,10 +2308,10 @@ int PPPDelayedPacketsComparator(const void *a, const void *b)
char PPPRelatedPacketComparator(PPP_PACKET *a, PPP_PACKET *b) char PPPRelatedPacketComparator(PPP_PACKET *a, PPP_PACKET *b)
{ {
if (a->IsControl && b->IsControl && if (a->IsControl && b->IsControl &&
a->Lcp != NULL && b->Lcp != NULL && a->Lcp != NULL && b->Lcp != NULL &&
a->Protocol == b->Protocol && a->Protocol == b->Protocol &&
PPP_CODE_IS_REQUEST(a->Protocol, a->Lcp->Code) == PPP_CODE_IS_REQUEST(b->Protocol, b->Lcp->Code) && PPP_CODE_IS_REQUEST(a->Protocol, a->Lcp->Code) == PPP_CODE_IS_REQUEST(b->Protocol, b->Lcp->Code) &&
PPP_CODE_IS_RESPONSE(a->Protocol, a->Lcp->Code) == PPP_CODE_IS_RESPONSE(b->Protocol, b->Lcp->Code)) PPP_CODE_IS_RESPONSE(a->Protocol, a->Lcp->Code) == PPP_CODE_IS_RESPONSE(b->Protocol, b->Lcp->Code))
{ {
// The packet is related! // The packet is related!
if (a->Lcp->Id < b->Lcp->Id) if (a->Lcp->Id < b->Lcp->Id)
@ -2636,21 +2636,21 @@ bool PPPParseMSCHAP2ResponsePacket(PPP_SESSION *p, PPP_PACKET *pp)
// Convert the MS-CHAPv2 data to a password string // Convert the MS-CHAPv2 data to a password string
BinToStr(server_challenge_hex, sizeof(server_challenge_hex), BinToStr(server_challenge_hex, sizeof(server_challenge_hex),
p->MsChapV2_ServerChallenge, sizeof(p->MsChapV2_ServerChallenge)); p->MsChapV2_ServerChallenge, sizeof(p->MsChapV2_ServerChallenge));
BinToStr(client_challenge_hex, sizeof(client_challenge_hex), BinToStr(client_challenge_hex, sizeof(client_challenge_hex),
p->MsChapV2_ClientChallenge, sizeof(p->MsChapV2_ClientChallenge)); p->MsChapV2_ClientChallenge, sizeof(p->MsChapV2_ClientChallenge));
BinToStr(client_response_hex, sizeof(client_response_hex), BinToStr(client_response_hex, sizeof(client_response_hex),
p->MsChapV2_ClientResponse, sizeof(p->MsChapV2_ClientResponse)); p->MsChapV2_ClientResponse, sizeof(p->MsChapV2_ClientResponse));
BinToStr(eap_client_hex, sizeof(eap_client_hex), BinToStr(eap_client_hex, sizeof(eap_client_hex),
&eap_client_ptr, 8); &eap_client_ptr, 8);
Format(password, sizeof(password), "%s%s:%s:%s:%s:%s", Format(password, sizeof(password), "%s%s:%s:%s:%s:%s",
IPC_PASSWORD_MSCHAPV2_TAG, IPC_PASSWORD_MSCHAPV2_TAG,
username_tmp, username_tmp,
server_challenge_hex, server_challenge_hex,
client_challenge_hex, client_challenge_hex,
client_response_hex, client_response_hex,
eap_client_hex); eap_client_hex);
if (p->MsChapV2_UseDoubleMsChapV2 && p->EapClient == NULL) if (p->MsChapV2_UseDoubleMsChapV2 && p->EapClient == NULL)
{ {
@ -2673,9 +2673,9 @@ bool PPPParseMSCHAP2ResponsePacket(PPP_SESSION *p, PPP_PACKET *pp)
{ {
Debug("MSCHAPv2 creating IPC\n"); Debug("MSCHAPv2 creating IPC\n");
ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, hub, id, password, ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, hub, id, password,
&error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort,
p->ClientHostname, p->CryptName, false, p->AdjustMss, p->EapClient, NULL, p->ClientHostname, p->CryptName, false, p->AdjustMss, p->EapClient, NULL,
+ IPC_LAYER_3); + IPC_LAYER_3);
if (ipc != NULL) if (ipc != NULL)
{ {
@ -2953,7 +2953,7 @@ bool PPPSetIPAddressValueToLCP(PPP_LCP *c, UINT type, IP *ip, bool only_modify)
{ {
PPP_OPTION *opt2 = NewPPPOption(type, &ui, 4); PPP_OPTION *opt2 = NewPPPOption(type, &ui, 4);
UCHAR ipstr[MAX_SIZE]; UCHAR ipstr[MAX_SIZE];
opt2->IsAccepted = true; opt2->IsAccepted = true;
opt2->IsSupported = true; opt2->IsSupported = true;
Copy(opt2->AltData, opt2->Data, opt2->DataSize); Copy(opt2->AltData, opt2->Data, opt2->DataSize);
@ -3082,9 +3082,9 @@ bool PPPProcessEAPTlsResponse(PPP_SESSION *p, PPP_EAP *eap_packet, UINT eapTlsSi
PPPParseUsername(p->Cedar, p->Eap_Identity, &d); PPPParseUsername(p->Cedar, p->Eap_Identity, &d);
ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, d.HubName, d.UserName, "", ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, d.HubName, d.UserName, "",
&error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort,
p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, p->Eap_TlsCtx.ClientCert.X, p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, p->Eap_TlsCtx.ClientCert.X,
IPC_LAYER_3); IPC_LAYER_3);
if (ipc != NULL) if (ipc != NULL)
{ {
@ -3415,7 +3415,7 @@ void FreePPPSession(PPP_SESSION *p)
Free(t); Free(t);
} }
ReleaseList(p->SentReqPacketList); ReleaseList(p->SentReqPacketList);
for (i = 0; i < LIST_NUM(p->DelayedPackets); i++) for (i = 0; i < LIST_NUM(p->DelayedPackets); i++)
@ -3425,7 +3425,7 @@ void FreePPPSession(PPP_SESSION *p)
Free(t); Free(t);
} }
ReleaseList(p->DelayedPackets); ReleaseList(p->DelayedPackets);
if (p->CurrentPacket != NULL) if (p->CurrentPacket != NULL)
@ -3684,7 +3684,7 @@ void GenerateNtPasswordHash(UCHAR *dst, char *password)
tmp = ZeroMalloc(tmp_size); tmp = ZeroMalloc(tmp_size);
for (i = 0;i < len;i++) for (i = 0; i < len; i++)
{ {
tmp[i * 2] = password[i]; tmp[i * 2] = password[i];
} }
@ -3852,7 +3852,7 @@ char *MsChapV2DoBruteForce(IPC_MSCHAP_V2_AUTHINFO *d, LIST *password_list)
return NULL; return NULL;
} }
for (i = 0;i < LIST_NUM(password_list);i++) for (i = 0; i < LIST_NUM(password_list); i++)
{ {
char *s = LIST_DATA(password_list, i); char *s = LIST_DATA(password_list, i);
char tmp[MAX_SIZE]; char tmp[MAX_SIZE];
@ -3864,7 +3864,7 @@ char *MsChapV2DoBruteForce(IPC_MSCHAP_V2_AUTHINFO *d, LIST *password_list)
len = StrLen(tmp); len = StrLen(tmp);
max = Power(2, MIN(len, 9)); max = Power(2, MIN(len, 9));
for (j = 0;j < max;j++) for (j = 0; j < max; j++)
{ {
SetStrCaseAccordingToBits(tmp, j); SetStrCaseAccordingToBits(tmp, j);
if (MsChapV2VerityPassword(d, tmp)) if (MsChapV2VerityPassword(d, tmp))

2
src/Cedar/Proto_PPP.h
View File

@ -311,7 +311,7 @@ struct PPP_SESSION
PPP_EAP_TLS_CONTEXT Eap_TlsCtx; // Context information for EAP TLS. May be possibly reused for EAP TTLS? PPP_EAP_TLS_CONTEXT Eap_TlsCtx; // Context information for EAP TLS. May be possibly reused for EAP TTLS?
LIST *SentReqPacketList; // Sent requests list LIST *SentReqPacketList; // Sent requests list
PPP_PACKET *CurrentPacket; PPP_PACKET *CurrentPacket;
LIST *DelayedPackets; LIST *DelayedPackets;

864
src/Mayaqua/Network.c
View File

File diff suppressed because it is too large Load Diff

20
src/Mayaqua/Network.h
View File

@ -357,7 +357,7 @@ typedef struct SOCKLIST
// Parameters for timeout thread for Solaris // Parameters for timeout thread for Solaris
typedef struct SOCKET_TIMEOUT_PARAM{ typedef struct SOCKET_TIMEOUT_PARAM {
SOCK *sock; SOCK *sock;
CANCEL *cancel; CANCEL *cancel;
THREAD *thread; THREAD *thread;
@ -651,7 +651,7 @@ struct RUDP_SESSION
UINT64 Magic_Disconnect; // Disconnection Signal UINT64 Magic_Disconnect; // Disconnection Signal
UINT64 NextSendSeqNo; // Transmission sequence number to be used next UINT64 NextSendSeqNo; // Transmission sequence number to be used next
UINT64 LastRecvCompleteSeqNo; // Sequence number of receiving complete UINT64 LastRecvCompleteSeqNo; // Sequence number of receiving complete
// (This indicates all segments which have sequence number up to this number are received completely) // (This indicates all segments which have sequence number up to this number are received completely)
UCHAR NextIv[SHA1_SIZE]; // IV value to be used next UCHAR NextIv[SHA1_SIZE]; // IV value to be used next
UINT NextKeepAliveInterval; // Interval value of KeepAlive to be used next UINT NextKeepAliveInterval; // Interval value of KeepAlive to be used next
FIFO *RecvFifo; // Reception FIFO FIFO *RecvFifo; // Reception FIFO
@ -846,7 +846,7 @@ struct CONNECT_TCP_RUDP_PARAM
#define SSL_DEFAULT_CONNECT_TIMEOUT (15 * 1000) // SSL default timeout #define SSL_DEFAULT_CONNECT_TIMEOUT (15 * 1000) // SSL default timeout
// Header for TCP Pair // Header for TCP Pair
struct TCP_PAIR_HEADER struct TCP_PAIR_HEADER
{ {
bool EnableHMac; bool EnableHMac;
@ -949,7 +949,7 @@ UINT64 RUDPGetCurrentSendingMinSeqNo(RUDP_SESSION *se);
UINT64 RUDPGetCurrentSendingMaxSeqNo(RUDP_SESSION *se); UINT64 RUDPGetCurrentSendingMaxSeqNo(RUDP_SESSION *se);
SOCK *ListenRUDP(char *svc_name, RUDP_STACK_INTERRUPTS_PROC *proc_interrupts, RUDP_STACK_RPC_RECV_PROC *proc_rpc_recv, void *param, UINT port, bool no_natt_register, bool over_dns_mode); SOCK *ListenRUDP(char *svc_name, RUDP_STACK_INTERRUPTS_PROC *proc_interrupts, RUDP_STACK_RPC_RECV_PROC *proc_rpc_recv, void *param, UINT port, bool no_natt_register, bool over_dns_mode);
SOCK *ListenRUDPEx(char *svc_name, RUDP_STACK_INTERRUPTS_PROC *proc_interrupts, RUDP_STACK_RPC_RECV_PROC *proc_rpc_recv, void *param, UINT port, bool no_natt_register, bool over_dns_mode, SOCK *ListenRUDPEx(char *svc_name, RUDP_STACK_INTERRUPTS_PROC *proc_interrupts, RUDP_STACK_RPC_RECV_PROC *proc_rpc_recv, void *param, UINT port, bool no_natt_register, bool over_dns_mode,
volatile UINT *natt_global_udp_port, UCHAR rand_port_id, IP *listen_ip); volatile UINT *natt_global_udp_port, UCHAR rand_port_id, IP *listen_ip);
SOCK *AcceptRUDP(SOCK *s); SOCK *AcceptRUDP(SOCK *s);
void *InitWaitUntilHostIPAddressChanged(); void *InitWaitUntilHostIPAddressChanged();
void FreeWaitUntilHostIPAddressChanged(void *p); void FreeWaitUntilHostIPAddressChanged(void *p);
@ -1303,13 +1303,13 @@ bool IsInSameNetwork4(IP *a1, IP *a2, IP *subnet);
bool IsInSameNetwork4Standard(IP *a1, IP *a2); bool IsInSameNetwork4Standard(IP *a1, IP *a2);
// Utility functions about IP and MAC address types // Utility functions about IP and MAC address types
bool IsValidUnicastIPAddress4(IP* ip); bool IsValidUnicastIPAddress4(IP *ip);
bool IsValidUnicastIPAddressUINT4(UINT ip); bool IsValidUnicastIPAddressUINT4(UINT ip);
bool IsValidUnicastIPAddress6(IP* ip); bool IsValidUnicastIPAddress6(IP *ip);
bool IsMacUnicast(UCHAR* mac); bool IsMacUnicast(UCHAR *mac);
bool IsMacBroadcast(UCHAR* mac); bool IsMacBroadcast(UCHAR *mac);
bool IsMacMulticast(UCHAR* mac); bool IsMacMulticast(UCHAR *mac);
bool IsMacInvalid(UCHAR* mac); bool IsMacInvalid(UCHAR *mac);
bool ParseIpAndSubnetMask4(char *src, UINT *ip, UINT *mask); bool ParseIpAndSubnetMask4(char *src, UINT *ip, UINT *mask);
bool ParseIpAndSubnetMask46(char *src, IP *ip, IP *mask); bool ParseIpAndSubnetMask46(char *src, IP *ip, IP *mask);

158
src/Mayaqua/TcpIp.c
View File

@ -84,7 +84,7 @@ ICMP_RESULT *IcmpParseResult(IP *dest_ip, USHORT src_id, USHORT src_seqno, UCHAR
ret->Ttl = ipv4->TimeToLive; ret->Ttl = ipv4->TimeToLive;
ret->DataSize = icmp_packet_size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)); ret->DataSize = icmp_packet_size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
ret->Data = Clone(recv_buffer + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO), ret->Data = Clone(recv_buffer + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO),
ret->DataSize); ret->DataSize);
Copy(&ret->IpAddress, &ip, sizeof(IP)); Copy(&ret->IpAddress, &ip, sizeof(IP));
} }
} }
@ -123,7 +123,7 @@ ICMP_RESULT *IcmpParseResult(IP *dest_ip, USHORT src_id, USHORT src_seqno, UCHAR
ret->Ttl = ipv4->TimeToLive; ret->Ttl = ipv4->TimeToLive;
ret->DataSize = icmp_packet_size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO)); ret->DataSize = icmp_packet_size - (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO));
ret->Data = Clone(recv_buffer + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO), ret->Data = Clone(recv_buffer + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO),
ret->DataSize); ret->DataSize);
Copy(&ret->IpAddress, &ip, sizeof(IP)); Copy(&ret->IpAddress, &ip, sizeof(IP));
} }
} }
@ -540,9 +540,9 @@ bool AdjustTcpMssL3(UCHAR *src, UINT src_size, UINT mss)
} }
if (((tcp->Flag & TCP_SYN) == false) || if (((tcp->Flag & TCP_SYN) == false) ||
((tcp->Flag & TCP_RST) || ((tcp->Flag & TCP_RST) ||
(tcp->Flag & TCP_PSH) || (tcp->Flag & TCP_PSH) ||
(tcp->Flag & TCP_URG))) (tcp->Flag & TCP_URG)))
{ {
// Not a SYN packet // Not a SYN packet
return false; return false;
@ -591,7 +591,7 @@ bool AdjustTcpMssL3(UCHAR *src, UINT src_size, UINT mss)
{ {
// Calculate the TCPv6 checksum // Calculate the TCPv6 checksum
tcp->Checksum = CalcChecksumForIPv6(&ip6->SrcAddress, &ip6->DestAddress, tcp->Checksum = CalcChecksumForIPv6(&ip6->SrcAddress, &ip6->DestAddress,
IP_PROTO_TCP, tcp, tcp_size, 0); IP_PROTO_TCP, tcp, tcp_size, 0);
} }
return true; return true;
@ -736,7 +736,7 @@ void VLanInsertTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vla
USHORT vlan_tpid_ushort; USHORT vlan_tpid_ushort;
// Validate arguments // Validate arguments
if (packet_data == NULL || *packet_data == NULL || packet_size == NULL || if (packet_data == NULL || *packet_data == NULL || packet_size == NULL ||
*packet_size < 14 || vlan_id == 0) *packet_size < 14 || vlan_id == 0)
{ {
return; return;
} }
@ -774,7 +774,7 @@ bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vla
UCHAR *vlan_tpid_uchar; UCHAR *vlan_tpid_uchar;
// Validate arguments // Validate arguments
if (packet_data == NULL || *packet_data == NULL || packet_size == NULL || if (packet_data == NULL || *packet_data == NULL || packet_size == NULL ||
*packet_size < 14) *packet_size < 14)
{ {
return false; return false;
} }
@ -804,7 +804,7 @@ bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vla
UINT dest_size = src_size - 4; UINT dest_size = src_size - 4;
UINT i; UINT i;
for (i = 12;i < dest_size;i++) for (i = 12; i < dest_size; i++)
{ {
src_data[i] = src_data[i + 4]; src_data[i] = src_data[i + 4];
} }
@ -839,10 +839,10 @@ BUF *BuildICMPv6(IPV6_ADDR *src_ip, IPV6_ADDR *dest_ip, UCHAR hop_limit, UCHAR t
icmp->Type = type; icmp->Type = type;
icmp->Code = code; icmp->Code = code;
icmp->Checksum = CalcChecksumForIPv6(src_ip, dest_ip, IP_PROTO_ICMPV6, icmp, icmp->Checksum = CalcChecksumForIPv6(src_ip, dest_ip, IP_PROTO_ICMPV6, icmp,
sizeof(ICMP_HEADER) + size, 0); sizeof(ICMP_HEADER) + size, 0);
ret = BuildIPv6(dest_ip, src_ip, id, IP_PROTO_ICMPV6, hop_limit, icmp, ret = BuildIPv6(dest_ip, src_ip, id, IP_PROTO_ICMPV6, hop_limit, icmp,
sizeof(ICMP_HEADER) + size); sizeof(ICMP_HEADER) + size);
Free(icmp); Free(icmp);
@ -881,7 +881,7 @@ BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCH
WriteBufBuf(b2, b); WriteBufBuf(b2, b);
ret = BuildICMPv6(src_ip, target_ip, 255, ret = BuildICMPv6(src_ip, target_ip, 255,
ICMPV6_TYPE_NEIGHBOR_SOLICIATION, 0, b2->Buf, b2->Size, id); ICMPV6_TYPE_NEIGHBOR_SOLICIATION, 0, b2->Buf, b2->Size, id);
FreeBuf(b); FreeBuf(b);
FreeBuf(b2); FreeBuf(b2);
@ -889,7 +889,7 @@ BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCH
return ret; return ret;
} }
BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR* src_ip, IPV6_ADDR* target_ip, UCHAR* my_mac_address, UINT id) BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCHAR *my_mac_address, UINT id)
{ {
ICMPV6_OPTION_LIST opt; ICMPV6_OPTION_LIST opt;
ICMPV6_OPTION_LINK_LAYER link; ICMPV6_OPTION_LINK_LAYER link;
@ -919,7 +919,7 @@ BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR* src_ip, IPV6_ADDR* target_ip, UCHAR
WriteBufBuf(b2, b); WriteBufBuf(b2, b);
ret = BuildICMPv6(src_ip, target_ip, 255, ret = BuildICMPv6(src_ip, target_ip, 255,
ICMPV6_TYPE_ROUTER_SOLICIATION, 0, b2->Buf, b2->Size, id); ICMPV6_TYPE_ROUTER_SOLICIATION, 0, b2->Buf, b2->Size, id);
FreeBuf(b); FreeBuf(b);
FreeBuf(b2); FreeBuf(b2);
@ -977,7 +977,7 @@ void BuildAndAddIPv6PacketOptionHeader(BUF *b, IPV6_OPTION_HEADER *opt, UCHAR ne
// Build an IPv6 packet // Build an IPv6 packet
BUF *BuildIPv6(IPV6_ADDR *dest_ip, IPV6_ADDR *src_ip, UINT id, UCHAR protocol, UCHAR hop_limit, void *data, BUF *BuildIPv6(IPV6_ADDR *dest_ip, IPV6_ADDR *src_ip, UINT id, UCHAR protocol, UCHAR hop_limit, void *data,
UINT size) UINT size)
{ {
IPV6_HEADER_PACKET_INFO info; IPV6_HEADER_PACKET_INFO info;
IPV6_HEADER ip_header; IPV6_HEADER ip_header;
@ -1058,21 +1058,21 @@ BUF *BuildIPv6PacketHeader(IPV6_HEADER_PACKET_INFO *info, UINT *bytes_before_pay
if (info->HopHeader != NULL) if (info->HopHeader != NULL)
{ {
BuildAndAddIPv6PacketOptionHeader(b, info->HopHeader, BuildAndAddIPv6PacketOptionHeader(b, info->HopHeader,
IPv6GetNextHeaderFromQueue(q), info->HopHeaderSize); IPv6GetNextHeaderFromQueue(q), info->HopHeaderSize);
} }
// End point option header // End point option header
if (info->EndPointHeader != NULL) if (info->EndPointHeader != NULL)
{ {
BuildAndAddIPv6PacketOptionHeader(b, info->EndPointHeader, BuildAndAddIPv6PacketOptionHeader(b, info->EndPointHeader,
IPv6GetNextHeaderFromQueue(q), info->EndPointHeaderSize); IPv6GetNextHeaderFromQueue(q), info->EndPointHeaderSize);
} }
// Routing header // Routing header
if (info->RoutingHeader != NULL) if (info->RoutingHeader != NULL)
{ {
BuildAndAddIPv6PacketOptionHeader(b, info->RoutingHeader, BuildAndAddIPv6PacketOptionHeader(b, info->RoutingHeader,
IPv6GetNextHeaderFromQueue(q), info->RoutingHeaderSize); IPv6GetNextHeaderFromQueue(q), info->RoutingHeaderSize);
} }
// Fragment header // Fragment header
@ -1362,22 +1362,22 @@ PKT *ClonePacket(PKT *p, bool copy_data)
Copy(ret->L3.IPv6Header, p->L3.IPv6Header, sizeof(IPV6_HEADER)); Copy(ret->L3.IPv6Header, p->L3.IPv6Header, sizeof(IPV6_HEADER));
ret->IPv6HeaderPacketInfo.IPv6Header = Clone(p->IPv6HeaderPacketInfo.IPv6Header, ret->IPv6HeaderPacketInfo.IPv6Header = Clone(p->IPv6HeaderPacketInfo.IPv6Header,
sizeof(IPV6_HEADER)); sizeof(IPV6_HEADER));
ret->IPv6HeaderPacketInfo.HopHeader = Clone(p->IPv6HeaderPacketInfo.HopHeader, ret->IPv6HeaderPacketInfo.HopHeader = Clone(p->IPv6HeaderPacketInfo.HopHeader,
sizeof(IPV6_OPTION_HEADER)); sizeof(IPV6_OPTION_HEADER));
ret->IPv6HeaderPacketInfo.EndPointHeader = Clone(p->IPv6HeaderPacketInfo.EndPointHeader, ret->IPv6HeaderPacketInfo.EndPointHeader = Clone(p->IPv6HeaderPacketInfo.EndPointHeader,
sizeof(IPV6_OPTION_HEADER)); sizeof(IPV6_OPTION_HEADER));
ret->IPv6HeaderPacketInfo.RoutingHeader = Clone(p->IPv6HeaderPacketInfo.RoutingHeader, ret->IPv6HeaderPacketInfo.RoutingHeader = Clone(p->IPv6HeaderPacketInfo.RoutingHeader,
sizeof(IPV6_OPTION_HEADER)); sizeof(IPV6_OPTION_HEADER));
ret->IPv6HeaderPacketInfo.FragmentHeader = Clone(p->IPv6HeaderPacketInfo.FragmentHeader, ret->IPv6HeaderPacketInfo.FragmentHeader = Clone(p->IPv6HeaderPacketInfo.FragmentHeader,
sizeof(IPV6_FRAGMENT_HEADER)); sizeof(IPV6_FRAGMENT_HEADER));
ret->IPv6HeaderPacketInfo.Payload = Clone(p->IPv6HeaderPacketInfo.Payload, ret->IPv6HeaderPacketInfo.Payload = Clone(p->IPv6HeaderPacketInfo.Payload,
p->IPv6HeaderPacketInfo.PayloadSize); p->IPv6HeaderPacketInfo.PayloadSize);
break; break;
} }
@ -1397,10 +1397,10 @@ PKT *ClonePacket(PKT *p, bool copy_data)
Copy(ret->L4.ICMPHeader, p->L4.ICMPHeader, sizeof(ICMP_HEADER)); Copy(ret->L4.ICMPHeader, p->L4.ICMPHeader, sizeof(ICMP_HEADER));
ret->ICMPv6HeaderPacketInfo.Data = Clone(p->ICMPv6HeaderPacketInfo.Data, ret->ICMPv6HeaderPacketInfo.Data = Clone(p->ICMPv6HeaderPacketInfo.Data,
p->ICMPv6HeaderPacketInfo.DataSize); p->ICMPv6HeaderPacketInfo.DataSize);
ret->ICMPv6HeaderPacketInfo.EchoData = Clone(p->ICMPv6HeaderPacketInfo.EchoData, ret->ICMPv6HeaderPacketInfo.EchoData = Clone(p->ICMPv6HeaderPacketInfo.EchoData,
p->ICMPv6HeaderPacketInfo.EchoDataSize); p->ICMPv6HeaderPacketInfo.EchoDataSize);
switch (ret->ICMPv6HeaderPacketInfo.Type) switch (ret->ICMPv6HeaderPacketInfo.Type)
{ {
@ -1410,31 +1410,31 @@ PKT *ClonePacket(PKT *p, bool copy_data)
case ICMPV6_TYPE_ROUTER_SOLICIATION: case ICMPV6_TYPE_ROUTER_SOLICIATION:
ret->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader = ret->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader, Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader,
sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)); sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER));
break; break;
case ICMPV6_TYPE_ROUTER_ADVERTISEMENT: case ICMPV6_TYPE_ROUTER_ADVERTISEMENT:
ret->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader = ret->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader, Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader,
sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)); sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER));
break; break;
case ICMPV6_TYPE_NEIGHBOR_SOLICIATION: case ICMPV6_TYPE_NEIGHBOR_SOLICIATION:
ret->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader = ret->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader, Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader,
sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)); sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER));
break; break;
case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT:
ret->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader = ret->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader =
Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader, Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader,
sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)); sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER));
break; break;
} }
CloneICMPv6Options(&ret->ICMPv6HeaderPacketInfo.OptionList, CloneICMPv6Options(&ret->ICMPv6HeaderPacketInfo.OptionList,
&p->ICMPv6HeaderPacketInfo.OptionList); &p->ICMPv6HeaderPacketInfo.OptionList);
break; break;
case L4_TCP: case L4_TCP:
@ -1465,10 +1465,10 @@ PKT *ClonePacket(PKT *p, bool copy_data)
ret->L7.IkeHeader = MallocFast(sizeof(IKE_HEADER)); ret->L7.IkeHeader = MallocFast(sizeof(IKE_HEADER));
Copy(ret->L7.IkeHeader, p->L7.IkeHeader, sizeof(IKE_HEADER)); Copy(ret->L7.IkeHeader, p->L7.IkeHeader, sizeof(IKE_HEADER));
break; break;
case L7_DNS: case L7_DNS:
StrCpy(ret->DnsQueryHost, sizeof(ret->DnsQueryHost), p->DnsQueryHost); StrCpy(ret->DnsQueryHost, sizeof(ret->DnsQueryHost), p->DnsQueryHost);
break; break;
} }
// Address data // Address data
@ -1491,7 +1491,7 @@ PKT *ClonePacket(PKT *p, bool copy_data)
} }
// Parse the packet but without data layer except for ICMP // Parse the packet but without data layer except for ICMP
PKT* ParsePacketUpToICMPv6(UCHAR* buf, UINT size) PKT *ParsePacketUpToICMPv6(UCHAR *buf, UINT size)
{ {
return ParsePacketEx5(buf, size, false, 0, true, true, false, true); return ParsePacketEx5(buf, size, false, 0, true, true, false, true);
} }
@ -1513,11 +1513,11 @@ PKT *ParsePacketEx3(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool b
{ {
return ParsePacketEx4(buf, size, no_l3, vlan_type_id, bridge_id_as_mac_address, false, false); return ParsePacketEx4(buf, size, no_l3, vlan_type_id, bridge_id_as_mac_address, false, false);
} }
PKT* ParsePacketEx4(UCHAR* buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum) PKT *ParsePacketEx4(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum)
{ {
return ParsePacketEx5(buf, size, no_l3, vlan_type_id, bridge_id_as_mac_address, no_http, correct_checksum, false); return ParsePacketEx5(buf, size, no_l3, vlan_type_id, bridge_id_as_mac_address, no_http, correct_checksum, false);
} }
PKT* ParsePacketEx5(UCHAR* buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum, bool no_l3_l4_except_icmpv6) PKT *ParsePacketEx5(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum, bool no_l3_l4_except_icmpv6)
{ {
PKT *p; PKT *p;
USHORT vlan_type_id_16; USHORT vlan_type_id_16;
@ -1643,7 +1643,7 @@ PKT* ParsePacketEx5(UCHAR* buf, UINT size, bool no_l3, UINT vlan_type_id, bool b
{ {
TCP_HEADER *tcp = p->L4.TCPHeader; TCP_HEADER *tcp = p->L4.TCPHeader;
if (tcp != NULL && (tcp->DstPort == port_raw || tcp->DstPort == port_raw2 || tcp->DstPort == port_raw4) && if (tcp != NULL && (tcp->DstPort == port_raw || tcp->DstPort == port_raw2 || tcp->DstPort == port_raw4) &&
(!((tcp->Flag & TCP_SYN) || (tcp->Flag & TCP_RST) || (tcp->Flag & TCP_FIN)))) (!((tcp->Flag & TCP_SYN) || (tcp->Flag & TCP_RST) || (tcp->Flag & TCP_FIN))))
{ {
if (p->PayloadSize >= 1) if (p->PayloadSize >= 1)
{ {
@ -1651,7 +1651,7 @@ PKT* ParsePacketEx5(UCHAR* buf, UINT size, bool no_l3, UINT vlan_type_id, bool b
} }
} }
if (tcp != NULL && tcp->DstPort == port_raw3 && if (tcp != NULL && tcp->DstPort == port_raw3 &&
(!((tcp->Flag & TCP_SYN) || (tcp->Flag & TCP_RST) || (tcp->Flag & TCP_FIN)))) (!((tcp->Flag & TCP_SYN) || (tcp->Flag & TCP_RST) || (tcp->Flag & TCP_FIN))))
{ {
if (p->PayloadSize >= 1) if (p->PayloadSize >= 1)
{ {
@ -1879,8 +1879,8 @@ HTTPLOG *ParseHttpAccessLog(PKT *pkt)
// Check whether it starts with the HTTP-specific string // Check whether it starts with the HTTP-specific string
if (CmpCaseIgnore(buf, "GET ", 4) != 0 && if (CmpCaseIgnore(buf, "GET ", 4) != 0 &&
CmpCaseIgnore(buf, "HEAD ", 5) != 0 && CmpCaseIgnore(buf, "HEAD ", 5) != 0 &&
CmpCaseIgnore(buf, "POST ", 5) != 0) CmpCaseIgnore(buf, "POST ", 5) != 0)
{ {
return NULL; return NULL;
} }
@ -2004,7 +2004,7 @@ bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3, bool no_l3_l4_ex
p->BroadcastPacket = true; p->BroadcastPacket = true;
b1 = true; b1 = true;
b2 = true; b2 = true;
for (i = 0;i < 6;i++) for (i = 0; i < 6; i++)
{ {
if (p->MacHeader->DestAddress[i] != 0xff) if (p->MacHeader->DestAddress[i] != 0xff)
{ {
@ -2080,7 +2080,7 @@ bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3, bool no_l3_l4_ex
else else
{ {
// Old IEEE 802.3 frame (payload length of the packet is written in the header) // Old IEEE 802.3 frame (payload length of the packet is written in the header)
// (It has been used in the BPDU, etc.) // (It has been used in the BPDU, etc.)
UINT length = (UINT)type_id_16; UINT length = (UINT)type_id_16;
LLC_HEADER *llc; LLC_HEADER *llc;
@ -2482,10 +2482,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size)
} }
icmp_info.Headers.RouterSoliciationHeader = icmp_info.Headers.RouterSoliciationHeader =
(ICMPV6_ROUTER_SOLICIATION_HEADER *)(((UCHAR *)icmp_info.Data)); (ICMPV6_ROUTER_SOLICIATION_HEADER *)(((UCHAR *)icmp_info.Data));
if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER), if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER),
icmp_info.DataSize - sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)) == false) icmp_info.DataSize - sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)) == false)
{ {
return false; return false;
} }
@ -2500,10 +2500,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size)
} }
icmp_info.Headers.RouterAdvertisementHeader = icmp_info.Headers.RouterAdvertisementHeader =
(ICMPV6_ROUTER_ADVERTISEMENT_HEADER *)(((UCHAR *)icmp_info.Data)); (ICMPV6_ROUTER_ADVERTISEMENT_HEADER *)(((UCHAR *)icmp_info.Data));
if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER), if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER),
icmp_info.DataSize - sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)) == false) icmp_info.DataSize - sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)) == false)
{ {
return false; return false;
} }
@ -2518,10 +2518,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size)
} }
icmp_info.Headers.NeighborSoliciationHeader = icmp_info.Headers.NeighborSoliciationHeader =
(ICMPV6_NEIGHBOR_SOLICIATION_HEADER *)(((UCHAR *)icmp_info.Data)); (ICMPV6_NEIGHBOR_SOLICIATION_HEADER *)(((UCHAR *)icmp_info.Data));
if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER), if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER),
icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)) == false) icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)) == false)
{ {
return false; return false;
} }
@ -2536,10 +2536,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size)
} }
icmp_info.Headers.NeighborAdvertisementHeader = icmp_info.Headers.NeighborAdvertisementHeader =
(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER *)(((UCHAR *)icmp_info.Data)); (ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER *)(((UCHAR *)icmp_info.Data));
if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER), if (ParseICMPv6Options(&icmp_info.OptionList, ((UCHAR *)icmp_info.Headers.HeaderPointer) + sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER),
icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)) == false) icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)) == false)
{ {
return false; return false;
} }
@ -2634,7 +2634,7 @@ bool ParsePacketIPv6(PKT *p, UCHAR *buf, UINT size, bool no_l3_l4_except_icmpv6)
case IP_PROTO_TCP: // TCP case IP_PROTO_TCP: // TCP
if (no_l3_l4_except_icmpv6) if (no_l3_l4_except_icmpv6)
{ {
return true; return true;
} }
return ParseTCP(p, buf, size); return ParseTCP(p, buf, size);
@ -2987,7 +2987,7 @@ bool ParseUDP(PKT *p, UCHAR *buf, UINT size)
dst_port = Endian16(p->L4.UDPHeader->DstPort); dst_port = Endian16(p->L4.UDPHeader->DstPort);
if ((src_port == 67 && dst_port == 68) || if ((src_port == 67 && dst_port == 68) ||
(src_port == 68 && dst_port == 67)) (src_port == 68 && dst_port == 67))
{ {
if (p->TypeL3 == L3_IPV4) if (p->TypeL3 == L3_IPV4)
{ {
@ -2997,13 +2997,13 @@ bool ParseUDP(PKT *p, UCHAR *buf, UINT size)
return true; return true;
} }
} }
if (dst_port == 53) if (dst_port == 53)
{ {
ParseDNS(p, buf, size); ParseDNS(p, buf, size);
return true; return true;
} }
if (src_port == 500 || dst_port == 500 || src_port == 4500 || dst_port == 4500) if (src_port == 500 || dst_port == 500 || src_port == 4500 || dst_port == 4500)
{ {
@ -3012,8 +3012,8 @@ bool ParseUDP(PKT *p, UCHAR *buf, UINT size)
IKE_HEADER *ike_header = (IKE_HEADER *)p->Payload; IKE_HEADER *ike_header = (IKE_HEADER *)p->Payload;
if (ike_header->InitiatorCookie != 0 && ike_header->ResponderCookie == 0 && if (ike_header->InitiatorCookie != 0 && ike_header->ResponderCookie == 0 &&
(ike_header->ExchangeType == IKE_EXCHANGE_TYPE_MAIN || (ike_header->ExchangeType == IKE_EXCHANGE_TYPE_MAIN ||
ike_header->ExchangeType == IKE_EXCHANGE_TYPE_AGGRESSIVE)) ike_header->ExchangeType == IKE_EXCHANGE_TYPE_AGGRESSIVE))
{ {
// the IKE connection request packet is found // the IKE connection request packet is found
p->TypeL7 = L7_IKECONN; p->TypeL7 = L7_IKECONN;
@ -3303,7 +3303,7 @@ BUF *BuildDhcpOptionsBuf(LIST *o)
} }
b = NewBuf(); b = NewBuf();
for (i = 0;i < LIST_NUM(o);i++) for (i = 0; i < LIST_NUM(o); i++)
{ {
DHCP_OPTION *d = LIST_DATA(o, i); DHCP_OPTION *d = LIST_DATA(o, i);
UINT current_size = d->Size; UINT current_size = d->Size;
@ -3612,7 +3612,7 @@ void BuildClasslessRouteTableStr(char *str, UINT str_size, DHCP_CLASSLESS_ROUTE_
return; return;
} }
for (i = 0;i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES;i++) for (i = 0; i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES; i++)
{ {
DHCP_CLASSLESS_ROUTE *r = &t->Entries[i]; DHCP_CLASSLESS_ROUTE *r = &t->Entries[i];
@ -3684,7 +3684,7 @@ bool ParseClasslessRouteTableStr(DHCP_CLASSLESS_ROUTE_TABLE *d, char *str)
{ {
UINT i; UINT i;
for (i = 0;i < t->NumTokens;i++) for (i = 0; i < t->NumTokens; i++)
{ {
DHCP_CLASSLESS_ROUTE r; DHCP_CLASSLESS_ROUTE r;
@ -3784,7 +3784,7 @@ BUF *DhcpBuildClasslessRouteData(DHCP_CLASSLESS_ROUTE_TABLE *t)
b = NewBuf(); b = NewBuf();
for (i = 0;i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES;i++) for (i = 0; i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES; i++)
{ {
DHCP_CLASSLESS_ROUTE *r = &t->Entries[i]; DHCP_CLASSLESS_ROUTE *r = &t->Entries[i];
@ -3883,7 +3883,7 @@ void DhcpParseClasslessRouteData(DHCP_CLASSLESS_ROUTE_TABLE *t, void *data, UINT
Copy(&r.SubnetMask, &mask, sizeof(IP)); Copy(&r.SubnetMask, &mask, sizeof(IP));
r.SubnetMaskLen = subnet_mask_len; r.SubnetMaskLen = subnet_mask_len;
for (i = 0;i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES;i++) for (i = 0; i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES; i++)
{ {
if (Cmp(&t->Entries[i], &r, sizeof(DHCP_CLASSLESS_ROUTE)) == 0) if (Cmp(&t->Entries[i], &r, sizeof(DHCP_CLASSLESS_ROUTE)) == 0)
{ {
@ -3919,7 +3919,7 @@ DHCP_OPTION *GetDhcpOption(LIST *o, UINT id)
return NULL; return NULL;
} }
for (i = 0;i < LIST_NUM(o);i++) for (i = 0; i < LIST_NUM(o); i++)
{ {
DHCP_OPTION *opt = LIST_DATA(o, i); DHCP_OPTION *opt = LIST_DATA(o, i);
if (opt->Id == id) if (opt->Id == id)
@ -3947,7 +3947,7 @@ DHCP_CLASSLESS_ROUTE *GetBestClasslessRoute(DHCP_CLASSLESS_ROUTE_TABLE *t, IP *i
return NULL; return NULL;
} }
for (i = 0;i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES;i++) for (i = 0; i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES; i++)
{ {
DHCP_CLASSLESS_ROUTE *e = &t->Entries[i]; DHCP_CLASSLESS_ROUTE *e = &t->Entries[i];
@ -3977,7 +3977,7 @@ void FreeDhcpOptions(LIST *o)
return; return;
} }
for (i = 0;i < LIST_NUM(o);i++) for (i = 0; i < LIST_NUM(o); i++)
{ {
DHCP_OPTION *opt = LIST_DATA(o, i); DHCP_OPTION *opt = LIST_DATA(o, i);
Free(opt->Data); Free(opt->Data);
@ -4096,10 +4096,10 @@ BUF *DhcpModifyIPv4(DHCP_MODIFY_OPTION *m, void *data, UINT size)
udp->Checksum = 0; udp->Checksum = 0;
udp->Checksum = CalcChecksumForIPv4(p->L3.IPv4Header->SrcIP, udp->Checksum = CalcChecksumForIPv4(p->L3.IPv4Header->SrcIP,
p->L3.IPv4Header->DstIP, p->L3.IPv4Header->DstIP,
IP_PROTO_UDP, IP_PROTO_UDP,
udp, udp,
p->PacketSize - (UINT)(((UCHAR *)udp) - ((UCHAR *)p->PacketData)), 0); p->PacketSize - (UINT)(((UCHAR *)udp) - ((UCHAR *)p->PacketData)), 0);
} }
FreePacket(p); FreePacket(p);
@ -4183,7 +4183,7 @@ BUF *DhcpModify(DHCP_MODIFY_OPTION *m, void *data, UINT size)
// Rebuilding the options list // Rebuilding the options list
opt_list2 = NewListFast(NULL); opt_list2 = NewListFast(NULL);
for (i = 0;i < LIST_NUM(opt_list);i++) for (i = 0; i < LIST_NUM(opt_list); i++)
{ {
DHCP_OPTION *o = LIST_DATA(opt_list, i); DHCP_OPTION *o = LIST_DATA(opt_list, i);
DHCP_OPTION *o2 = NULL; DHCP_OPTION *o2 = NULL;

8
src/Mayaqua/TcpIp.h
View File

@ -745,8 +745,8 @@ PKT *ParsePacketEx(UCHAR *buf, UINT size, bool no_l3);
PKT *ParsePacketEx2(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id); PKT *ParsePacketEx2(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id);
PKT *ParsePacketEx3(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address); PKT *ParsePacketEx3(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address);
PKT *ParsePacketEx4(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum); PKT *ParsePacketEx4(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum);
PKT* ParsePacketEx5(UCHAR* buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum, bool no_l3_l4_except_icmpv6); PKT *ParsePacketEx5(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool bridge_id_as_mac_address, bool no_http, bool correct_checksum, bool no_l3_l4_except_icmpv6);
PKT* ParsePacketUpToICMPv6(UCHAR* buf, UINT size); PKT *ParsePacketUpToICMPv6(UCHAR *buf, UINT size);
void FreePacket(PKT *p); void FreePacket(PKT *p);
void FreePacketWithData(PKT *p); void FreePacketWithData(PKT *p);
void FreePacketIPv4(PKT *p); void FreePacketIPv4(PKT *p);
@ -783,12 +783,12 @@ USHORT CalcChecksumForIPv6(IPV6_ADDR *src_ip, IPV6_ADDR *dest_ip, UCHAR protocol
BUF *BuildICMPv6Options(ICMPV6_OPTION_LIST *o); BUF *BuildICMPv6Options(ICMPV6_OPTION_LIST *o);
void BuildICMPv6OptionValue(BUF *b, UCHAR type, void *header_pointer, UINT total_size); void BuildICMPv6OptionValue(BUF *b, UCHAR type, void *header_pointer, UINT total_size);
BUF *BuildIPv6(IPV6_ADDR *dest_ip, IPV6_ADDR *src_ip, UINT id, UCHAR protocol, UCHAR hop_limit, void *data, BUF *BuildIPv6(IPV6_ADDR *dest_ip, IPV6_ADDR *src_ip, UINT id, UCHAR protocol, UCHAR hop_limit, void *data,
UINT size); UINT size);
BUF *BuildIPv6PacketHeader(IPV6_HEADER_PACKET_INFO *info, UINT *bytes_before_payload); BUF *BuildIPv6PacketHeader(IPV6_HEADER_PACKET_INFO *info, UINT *bytes_before_payload);
UCHAR IPv6GetNextHeaderFromQueue(QUEUE *q); UCHAR IPv6GetNextHeaderFromQueue(QUEUE *q);
void BuildAndAddIPv6PacketOptionHeader(BUF *b, IPV6_OPTION_HEADER *opt, UCHAR next_header, UINT size); void BuildAndAddIPv6PacketOptionHeader(BUF *b, IPV6_OPTION_HEADER *opt, UCHAR next_header, UINT size);
BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCHAR *my_mac_address, UINT id); BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCHAR *my_mac_address, UINT id);
BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR* src_ip, IPV6_ADDR* target_ip, UCHAR* my_mac_address, UINT id); BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCHAR *my_mac_address, UINT id);
BUF *BuildICMPv6(IPV6_ADDR *src_ip, IPV6_ADDR *dest_ip, UCHAR hop_limit, UCHAR type, UCHAR code, void *data, UINT size, UINT id); BUF *BuildICMPv6(IPV6_ADDR *src_ip, IPV6_ADDR *dest_ip, UCHAR hop_limit, UCHAR type, UCHAR code, void *data, UINT size, UINT id);
bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vlan_tpid); bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vlan_tpid);