From 1d6a4d3ec8057c6094418c45d9aa7e2f1ceea5ba Mon Sep 17 00:00:00 2001 From: Evengard Date: Mon, 11 May 2020 16:35:33 +0300 Subject: [PATCH 1/6] Preliminary IPC IPv6 implementation (untested) --- src/Cedar/CedarType.h | 1 + src/Cedar/IPC.c | 564 ++++++++++++++++++++++++++++++++++++------ src/Cedar/IPC.h | 49 +++- src/Cedar/Virtual.c | 40 --- src/Cedar/Virtual.h | 2 - src/Mayaqua/Network.c | 169 +++++++++++++ src/Mayaqua/Network.h | 9 + src/Mayaqua/TcpIp.c | 70 +++++- src/Mayaqua/TcpIp.h | 7 +- 9 files changed, 785 insertions(+), 126 deletions(-) diff --git a/src/Cedar/CedarType.h b/src/Cedar/CedarType.h index e3124a8c..61f8c5b8 100644 --- a/src/Cedar/CedarType.h +++ b/src/Cedar/CedarType.h @@ -582,6 +582,7 @@ typedef struct IPC_PARAM IPC_PARAM; typedef struct IPC_DHCP_RELEASE_QUEUE IPC_DHCP_RELEASE_QUEUE; typedef struct IPC_MSCHAP_V2_AUTHINFO IPC_MSCHAP_V2_AUTHINFO; typedef struct IPC_SESSION_SHARED_BUFFER_DATA IPC_SESSION_SHARED_BUFFER_DATA; +typedef struct IPC_IPV6_ROUTER_ADVERTISEMENT IPC_IPV6_ROUTER_ADVERTISEMENT; // ============================================================== diff --git a/src/Cedar/IPC.c b/src/Cedar/IPC.c index 47ad93cb..d78524be 100644 --- a/src/Cedar/IPC.c +++ b/src/Cedar/IPC.c @@ -489,6 +489,8 @@ IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char // Create an IPv4 reception queue ipc->IPv4ReceivedQueue = NewQueue(); + IPCIPv6Init(ipc); + return ipc; LABEL_ERROR: @@ -531,6 +533,8 @@ IPC *NewIPCBySock(CEDAR *cedar, SOCK *s, void *mac_address) ipc->FlushList = NewTubeFlushList(); + IPCIPv6Init(ipc); + return ipc; } @@ -610,6 +614,8 @@ void FreeIPC(IPC *ipc) ReleaseSharedBuffer(ipc->IpcSessionSharedBuffer); + IPCIPv6Free(ipc); + Free(ipc); } @@ -1186,7 +1192,7 @@ void IPCProcessArp(IPC *ipc, BLOCK *b) if (CmpIpAddr(&target_ip, &ipc->ClientIPAddress) == 0) { // Create a response since a request for its own IP address have received - if (IsValidUnicastMacAddress(sender_mac)) + if (IsMacUnicast(sender_mac)) { UCHAR tmp[14 + sizeof(ARPV4_HEADER)]; ARPV4_HEADER *arp = (ARPV4_HEADER *)(tmp + 14); @@ -1218,7 +1224,7 @@ void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address) { IPC_ARP *a; // Validate arguments - if (ipc == NULL || ip == NULL || IsValidUnicastIPAddress4(ip) == false || IsValidUnicastMacAddress(mac_address) == false) + if (ipc == NULL || ip == NULL || IsValidUnicastIPAddress4(ip) == false || IsMacUnicast(mac_address) == false) { return; } @@ -1239,7 +1245,7 @@ void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address) } // Search whether there is ARP table entry already - a = IPCSearchArpTable(ipc, ip); + a = IPCSearchArpTable(ipc->ArpTable, ip); if (a == NULL) { // Add to the ARP table @@ -1278,68 +1284,6 @@ void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address) } } -// Identify whether the MAC address is a normal unicast address -bool IsValidUnicastMacAddress(UCHAR *mac) -{ - // Validate arguments - if (mac == NULL) - { - return false; - } - - if (mac[0] & 0x01) - { - return false; - } - - if (IsZero(mac, 6)) - { - return false; - } - - return true; -} - -// Identify whether the IP address is a normal unicast address -bool IsValidUnicastIPAddress4(IP *ip) -{ - UINT i; - // Validate arguments - if (IsIP4(ip) == false) - { - return false; - } - - if (IsZeroIP(ip)) - { - return false; - } - - if (ip->addr[0] >= 224 && ip->addr[0] <= 239) - { - // IPv4 Multicast - return false; - } - - for (i = 0;i < 4;i++) - { - if (ip->addr[i] != 255) - { - return true; - } - } - - return false; -} -bool IsValidUnicastIPAddressUINT4(UINT ip) -{ - IP a; - - UINTToIP(&a, ip); - - return IsValidUnicastIPAddress4(&a); -} - // Interrupt process (This is called periodically) void IPCProcessInterrupts(IPC *ipc) { @@ -1371,6 +1315,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) // Remove old ARP table entries IPCFlushArpTableEx(ipc, now); + IPCIPv6FlushNDTEx(ipc, now); // Receive all the L2 packet while (true) @@ -1390,10 +1335,10 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) // Confirm the destination MAC address // (Receive if the destination MAC address is the IPC address or a broadcast address) - if (Cmp(dest_mac, ipc->MacAddress, 6) == 0 || dest_mac[0] & 0x01) + if (Cmp(dest_mac, ipc->MacAddress, 6) == 0 || IsMacBroadcast(dest_mac) || IsMacMulticast(dest_mac)) { // If the source MAC address is itselves or invalid address, ignore the packet - if (Cmp(src_mac, ipc->MacAddress, 6) != 0 && IsValidUnicastMacAddress(src_mac)) + if (Cmp(src_mac, ipc->MacAddress, 6) != 0 && !IsMacUnicast(src_mac)) { if (protocol == MAC_PROTO_ARPV4) { @@ -1457,6 +1402,54 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) } } } + else if (protocol == MAC_PROTO_IPV6) + { + PKT* p = ParsePacketUpToICMPv6(b->Buf, b->Size); + if (p != NULL) + { + IP ip_src, ip_dst; + bool ndtProcessed = false; + + UCHAR* data = Clone(p->L3.IPv6Header, p->L3.IPv6Header->PayloadLength + sizeof(IPV6_HEADER)); + + IPv6AddrToIP(&ip_src, &p->IPv6HeaderPacketInfo.IPv6Header->SrcAddress); + IPv6AddrToIP(&ip_dst, &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress); + + if (p->IPv6HeaderPacketInfo.Protocol == IP_PROTO_ICMPV6) + { + IP icmpHeaderAddr; + // We need to parse the Router Advertisement and Neighbor Advertisement messages + // to build the Neighbor Discovery Table (aka ARP table for IPv6) + switch (p->ICMPv6HeaderPacketInfo.Type) + { + case ICMPV6_TYPE_ROUTER_ADVERTISEMENT: + // We save the router advertisement data for later use + IPCIPv6AddRouterPrefix(ipc, &p->ICMPv6HeaderPacketInfo.OptionList, src_mac, &ip_src); + IPCIPv6AssociateOnNDTEx(ipc, &ip_src, src_mac, true); + IPCIPv6AssociateOnNDTEx(ipc, &ip_src, &p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer, true); + break; + case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: + // We save the neighbor advertisements into NDT + IPv6AddrToIP(&icmpHeaderAddr, &p->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader->TargetAddress); + IPCIPv6AssociateOnNDTEx(ipc, &icmpHeaderAddr, src_mac, true); + IPCIPv6AssociateOnNDTEx(ipc, &ip_src, src_mac, true); + ndtProcessed = true; + break; + } + } + + // We update the NDT only if we have an entry in it for the IP+Mac + if (!ndtProcessed) + { + IPCIPv6AssociateOnNDT(ipc, &ip_src, src_mac); + } + + /// TODO: should we or not filter Neighbor Advertisements and/or Neighbor Solicitations? + InsertQueue(ipc->IPv6ReceivedQueue, data); + + FreePacket(p); + } + } } } } @@ -1725,7 +1718,7 @@ void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip) return; } - a = IPCSearchArpTable(ipc, next_ip); + a = IPCSearchArpTable(ipc->ArpTable, next_ip); if (a != NULL) { @@ -1789,19 +1782,19 @@ void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip) } // Search the ARP table -IPC_ARP *IPCSearchArpTable(IPC *ipc, IP *ip) +IPC_ARP *IPCSearchArpTable(LIST* arpTable, IP *ip) { IPC_ARP t; IPC_ARP *a; // Validate arguments - if (ipc == NULL || ip == NULL) + if (arpTable == NULL || ip == NULL) { return NULL; } Copy(&t.Ip, ip, sizeof(IP)); - a = Search(ipc->ArpTable, &t); + a = Search(arpTable, &t); return a; } @@ -1944,5 +1937,434 @@ BLOCK *IPCRecvL2(IPC *ipc) return b; } +// IPv6 stuff +// Memory management +void IPCIPv6Init(IPC* ipc) +{ + ipc->IPv6ReceivedQueue = NewQueue(); + // The NDT is basically the same as ARP Table with some slight adjustments + ipc->IPv6NeighborTable = NewList(IPCCmpArpTable); + ipc->IPv6RouterAdvs = NewList(NULL); +} +void IPCIPv6Free(IPC* ipc) +{ + UINT i; + for (i = 0; i < LIST_NUM(ipc->IPv6NeighborTable); i++) + { + IPC_ARP* a = LIST_DATA(ipc->IPv6NeighborTable, i); + IPCFreeARP(a); + } + ReleaseList(ipc->IPv6NeighborTable); + for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) + { + IPC_IPV6_ROUTER_ADVERTISEMENT* ra = LIST_DATA(ipc->IPv6RouterAdvs, i); + Free(ra); + } + + ReleaseList(ipc->IPv6RouterAdvs); + + while (true) + { + BLOCK* b = GetNext(ipc->IPv6ReceivedQueue); + if (b == NULL) + { + break; + } + + FreeBlock(b); + } + + ReleaseQueue(ipc->IPv6ReceivedQueue); +} + +// NDT +void IPCIPv6AssociateOnNDT(IPC* ipc, IP* ip, UCHAR* mac_address) +{ + IPCIPv6AssociateOnNDTEx(ipc, ip, mac_address, false); +} +void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighborAdv) +{ + IPC_ARP* a; + UINT addrType = 0; + if (ipc == NULL || ip == NULL || + IsValidUnicastIPAddress6(ip) == false || + IsMacUnicast(mac_address) == false) + { + return; + } + + addrType = GetIPAddrType6(ip); + + if (addrType != IPV6_ADDR_LOCAL_UNICAST && + addrType != IPV6_ADDR_GLOBAL_UNICAST) + { + return; + } + + if (addrType == IPV6_ADDR_GLOBAL_UNICAST) + { + if (!IPCIPv6CheckUnicastFromRouterPrefix(ipc, ip, NULL)) + { + return; + } + } + + a = IPCSearchArpTable(ipc->IPv6NeighborTable, ip); + + // We create a new entry only if we got a neighbor advertisement + if (a == NULL && isNeighborAdv) + { + a = IPCNewARP(ip, mac_address); + Insert(ipc->IPv6NeighborTable, a); + } + else if (a == NULL) + { + // We skip the NDT association on random packets from unknown locations + return; + } + else + { + Copy(a->MacAddress, mac_address, 6); + + if (a->Resolved == false) + { + a->Resolved = true; + a->GiveupTime = 0; + while (true) + { + BLOCK* b = GetNext(a->PacketQueue); + + if (b == NULL) + { + break; + } + + IPCIPv6SendWithDestMacAddr(ipc, b->Buf, b->Size, a->MacAddress); + + FreeBlock(b); + } + } + + a->ExpireTime = Tick64() + (UINT64)IPC_IPV6_NDT_LIFETIME; + } +} + +void IPCIPv6FlushNDT(IPC* ipc) +{ + IPCIPv6FlushNDTEx(ipc, 0); +} +void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now) +{ + UINT i; + LIST* o = NULL; + // Validate arguments + if (ipc == NULL) + { + return; + } + if (now == 0) + { + now = Tick64(); + } + + for (i = 0; i < LIST_NUM(ipc->IPv6NeighborTable); i++) + { + IPC_ARP* a = LIST_DATA(ipc->IPv6NeighborTable, i); + bool b = false; + + if (a->Resolved && a->ExpireTime <= now) + { + b = true; + } + else if (a->Resolved == false && a->GiveupTime <= now) + { + b = true; + } + /// TODO: think about adding retransmission as per RFC4861 + + if (b) + { + if (o == NULL) + { + o = NewListFast(NULL); + } + + Add(o, a); + } + } + + if (o != NULL) + { + for (i = 0; i < LIST_NUM(o); i++) + { + IPC_ARP* a = LIST_DATA(o, i); + + IPCFreeARP(a); + + Delete(ipc->IPv6NeighborTable, a); + } + + ReleaseList(o); + } +} + +// RA +void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* macAddress, IP* ip) +{ + UINT i; + bool foundPrefix = false; + for (i = 0; i < LIST_NUM(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) + { + foundPrefix = true; + break; + } + } + + if (!foundPrefix) + { + IPC_IPV6_ROUTER_ADVERTISEMENT* newRA = Malloc(sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); + IPv6AddrToIP(&newRA->RoutedPrefix, &recvPrefix->Prefix->Prefix); + IntToSubnetMask6(&newRA->RoutedMask, recvPrefix->Prefix->SubnetLength); + CopyIP(&newRA->RouterAddress, ip); + Copy(newRA->RouterMacAddress, macAddress, 6); + Copy(newRA->RouterLinkLayerAddress, recvPrefix->SourceLinkLayer->Address, 6); + Add(ipc->IPv6RouterAdvs, newRA); + } +} + +bool IPCIPv6CheckUnicastFromRouterPrefix(IPC* ipc, IP* ip, IPC_IPV6_ROUTER_ADVERTISEMENT* matchedRA) +{ + UINT i; + IPC_IPV6_ROUTER_ADVERTISEMENT* matchingRA = NULL; + bool isInPrefix = false; + for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) + { + IPC_IPV6_ROUTER_ADVERTISEMENT* ra = LIST_DATA(ipc->IPv6RouterAdvs, i); + isInPrefix = IsInSameNetwork6(ip, &ra->RoutedPrefix, &ra->RoutedMask); + if (isInPrefix) + { + matchingRA = ra; + break; + } + } + + if (matchedRA != NULL && matchingRA != NULL) + { + Copy(matchedRA, matchingRA, sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); + } + + return isInPrefix; +} + +// Send router solicitation and then eventually populate the info from Router Advertisements +void IPCIPv6SendRouterSolicitation(IPC* ipc) +{ + IP senderIP; + IP destIP; + UCHAR destMacAddress[6]; + IPV6_ADDR linkLocal; + BUF *packet; + Zero(&linkLocal, sizeof(IPV6_ADDR)); + + // Generate link local from client's EUI + linkLocal.Value[0] = 0xFE; + linkLocal.Value[1] = 0x80; + WRITE_UINT64(&linkLocal.Value[8], &ipc->IPv6ClientEUI); + + GetAllRouterMulticastAddress6(&destIP); + + // Generate the MAC address from the multicast address + destMacAddress[0] = 0x33; + destMacAddress[1] = 0x33; + WRITE_UINT(&destMacAddress[2], &destIP.ipv6_addr[12]); + + packet = BuildICMPv6RouterSoliciation(senderIP.ipv6_addr, destIP.ipv6_addr, ipc->MacAddress, 0); + + while (LIST_NUM(ipc->IPv6RouterAdvs) == 0) + { + UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); + UINT64 timeout_retry = Tick() + (UINT64)IPC_IPV6_RA_INTERVAL; + IPCIPv6SendWithDestMacAddr(ipc, packet->Buf, packet->Size, destMacAddress); + + AddInterrupt(ipc->Interrupt, timeout_retry); + + if (Tick64() >= giveup_time) + { + // We failed to receive any router advertisements + break; + } + + // The processing should populate the received RAs by itself + IPCProcessL3Events(ipc); + } +} + +// Data flow +BLOCK* IPCIPv6Recv(IPC* ipc) +{ + BLOCK* b; + // Validate arguments + if (ipc == NULL) + { + return NULL; + } + + b = GetNext(ipc->IPv6ReceivedQueue); + + return b; +} + +void IPCIPv6Send(IPC* ipc, void* data, UINT size) +{ + IP destAddr; + UINT ipv6Type; + UCHAR destMac[6]; + IPV6_HEADER* header = data; + + IPv6AddrToIP(&destAddr, &header->DestAddress); + + if (IsValidUnicastIPAddress6(&destAddr)) + { + IPCIPv6SendUnicast(ipc, data, size, &destAddr); + return; + } + + // Here we're probably dealing with a multicast packet. But let's check it anyway + ipv6Type = GetIPAddrType6(&destAddr); + if (ipv6Type & IPV6_ADDR_MULTICAST) + { + // Constructing multicast MAC address based on destination IP address, then just fire and forget + destMac[0] = 0x33; + destMac[1] = 0x33; + destMac[2] = destAddr.ipv6_addr[12]; + destMac[3] = destAddr.ipv6_addr[13]; + destMac[4] = destAddr.ipv6_addr[14]; + destMac[5] = destAddr.ipv6_addr[15]; + IPCIPv6SendWithDestMacAddr(ipc, data, size, destMac); + return; + } + else + { + Debug("We got a weird packet with a weird type! %i\n", ipv6Type); + } +} + +void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac_addr) +{ + UCHAR tmp[1514]; + // Validate arguments + if (ipc == NULL || data == NULL || size < 40 || size > 1500 || dest_mac_addr == NULL) + { + return; + } + + // Destination + Copy(tmp + 0, dest_mac_addr, 6); + + // Source + Copy(tmp + 6, ipc->MacAddress, 6); + + // Protocol number + WRITE_USHORT(tmp + 12, MAC_PROTO_IPV6); + + // Data + Copy(tmp + 14, data, size); + + // Send + IPCSendL2(ipc, tmp, size + 14); +} + +void IPCIPv6SendUnicast(IPC* ipc, void* data, UINT size, IP* next_ip) +{ + IPC_ARP* ndtMatch; + UCHAR* destMac = NULL; + IPC_IPV6_ROUTER_ADVERTISEMENT ra; + IPV6_HEADER* header = data; + IP srcIp; + bool isLocal = false; + // First we need to understand if it is a local packet or we should route it through the router + UINT addrType = GetIPAddrType6(next_ip); + + Zero(&ra, sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); + IPv6AddrToIP(&srcIp, &header->SrcAddress); + + // Link local is always local =) + if (addrType & IPV6_ADDR_LOCAL_UNICAST) + { + isLocal = true; + } + + // If it matches any received prefix from router advertisements, it's also local + if (!isLocal && IPCIPv6CheckUnicastFromRouterPrefix(ipc, next_ip, &ra)) + { + isLocal = true; + } + + // If it is a global packet, we need to get our source IP prefix to know through which router shall we route + if (!isLocal) + { + if (!IPCIPv6CheckUnicastFromRouterPrefix(ipc, &srcIp, &ra)) + { + // If we didn't find a router for the source IP, let's just try to pick the first router and try to send to it + if (LIST_NUM(ipc->IPv6RouterAdvs) > 0) + { + Copy(&ra, LIST_DATA(ipc->IPv6RouterAdvs, 0), sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); + } + else + { + CHAR tmp[MAX_SIZE]; + IPToStr6(tmp, MAX_SIZE, &srcIp); + Debug("We couldn't find a router for the source address of %s! Trying as local.\n", tmp); + isLocal = true; + } + } + + destMac = ra.RouterMacAddress; + if (!IsMacUnicast(destMac) && !IsMacInvalid(ra.RouterMacAddress)) + { + destMac = ra.RouterLinkLayerAddress; + } + } + + // If it is local it should be routed directly through the NDT + if (isLocal) + { + ndtMatch = IPCSearchArpTable(ipc->IPv6NeighborTable, next_ip); + if (ndtMatch == NULL) + { + // Creating a non-matched NDT entry + ndtMatch = IPCNewARP(next_ip, NULL); + Add(ipc->IPv6NeighborTable, ndtMatch); + } + if (ndtMatch->Resolved != true) + { + /// 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 + CHAR tmp[MAX_SIZE]; + BLOCK* blk = NewBlock(data, size, 0); + InsertQueue(ndtMatch->PacketQueue, blk); + 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); + + return; + } + destMac = ndtMatch->MacAddress; + } + + if (destMac != NULL && !IsMacInvalid(destMac)) + { + IPCIPv6SendWithDestMacAddr(ipc, data, size, destMac); + } + else + { + CHAR tmp[MAX_SIZE]; + IPToStr6(tmp, MAX_SIZE, next_ip); + Debug("We couldn't deduce the MAC address for unicast address %s, packet dropped.\n", tmp); + /// TODO: think about sending to the all routers broadcast MAC as a last resort + } +} diff --git a/src/Cedar/IPC.h b/src/Cedar/IPC.h index 0aa25b4a..bce2cd93 100644 --- a/src/Cedar/IPC.h +++ b/src/Cedar/IPC.h @@ -24,6 +24,12 @@ #define IPC_LAYER_2 2 #define IPC_LAYER_3 3 +// IPv6 constants +#define IPC_IPV6_NDT_LIFETIME (30 * 1000) // as per REACHABLE_TIME constant of RFC4861 +#define IPC_IPV6_NDT_GIVEUPTIME (3 * 1000) // as per MAX_MULTICAST_SOLICIT * RETRANS_TIMER constants of RFC4861 +#define IPC_IPV6_RA_INTERVAL (4 * 1000) // as per RTR_SOLICITATION_INTERVAL constant of RFC4861 +#define IPC_IPV6_RA_MAX_RETRIES 3 // as per MAX_RTR_SOLICITATIONS constant of RFC4861 + // ARP table entry struct IPC_ARP { @@ -117,6 +123,13 @@ struct IPC SHARED_BUFFER *IpcSessionSharedBuffer; // A shared buffer between IPC and Session IPC_SESSION_SHARED_BUFFER_DATA *IpcSessionShared; // Shared data between IPC and Session UINT Layer; + + // IPv6 stuff + QUEUE* IPv6ReceivedQueue; // IPv6 reception queue + LIST* IPv6NeighborTable; // Neighbor Discovery Table + LIST* IPv6RouterAdvs; // Router offered prefixes + UINT64 IPv6ClientEUI; // The EUI of the client (for the SLAAC autoconf) + UINT64 IPv6ServerEUI; // The EUI of the server (from the RA discovery) }; // MS-CHAPv2 authentication information @@ -129,6 +142,15 @@ struct IPC_MSCHAP_V2_AUTHINFO EAP_CLIENT *MsChapV2_EapClient; // EAP client }; +struct IPC_IPV6_ROUTER_ADVERTISEMENT +{ + IP RoutedPrefix; + IP RoutedMask; + IP RouterAddress; + UCHAR RouterMacAddress[6]; + UCHAR RouterLinkLayerAddress[6]; +}; + 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, char *client_hostname, char *crypt_name, @@ -151,15 +173,15 @@ IPC_ARP *IPCNewARP(IP *ip, UCHAR *mac_address); void IPCFreeARP(IPC_ARP *a); int IPCCmpArpTable(void *p1, void *p2); void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip); -IPC_ARP *IPCSearchArpTable(IPC *ipc, IP *ip); +IPC_ARP *IPCSearchArpTable(LIST* arpTable, IP *ip); void IPCSendIPv4WithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr); void IPCFlushArpTable(IPC *ipc); void IPCFlushArpTableEx(IPC *ipc, UINT64 now); void IPCProcessArp(IPC *ipc, BLOCK *b); void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address); -bool IsValidUnicastMacAddress(UCHAR *mac); -bool IsValidUnicastIPAddress4(IP *ip); -bool IsValidUnicastIPAddressUINT4(UINT ip); + + + DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION_LIST *opt, UINT expecting_code, UINT timeout, TUBE *discon_poll_tube); BUF *IPCBuildDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION_LIST *opt); BUF *IPCBuildDhcpRequestOptions(IPC *ipc, DHCP_OPTION_LIST *opt); @@ -171,6 +193,25 @@ IPC_ASYNC *NewIPCAsync(CEDAR *cedar, IPC_PARAM *param, SOCK_EVENT *sock_event); void IPCAsyncThreadProc(THREAD *thread, void *param); void FreeIPCAsync(IPC_ASYNC *a); +// IPv6 stuff +// Memory management +void IPCIPv6Init(IPC* ipc); +void IPCIPv6Free(IPC* ipc); +// NDT +void IPCIPv6AssociateOnNDT(IPC* ipc, IP* ip, UCHAR* mac_address); +void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighborAdv); +void IPCIPv6FlushNDT(IPC* ipc); +void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now); +// RA +void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* macAddress, IP* ip); +bool IPCIPv6CheckUnicastFromRouterPrefix(IPC* ipc, IP* ip, IPC_IPV6_ROUTER_ADVERTISEMENT* matchedRA); +void IPCIPv6SendRouterSolicitation(IPC* ipc); +// Data flow +BLOCK* IPCIPv6Recv(IPC* ipc); +void IPCIPv6Send(IPC* ipc, void* data, UINT size); +void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac_addr); +void IPCIPv6SendUnicast(IPC* ipc, void* data, UINT size, IP* next_ip); + bool ParseAndExtractMsChapV2InfoFromPassword(IPC_MSCHAP_V2_AUTHINFO *d, char *password); #endif // IPC_H diff --git a/src/Cedar/Virtual.c b/src/Cedar/Virtual.c index 1cac3370..26a27922 100644 --- a/src/Cedar/Virtual.c +++ b/src/Cedar/Virtual.c @@ -8220,46 +8220,6 @@ void FreeArpWaitTable(VH *v) ReleaseList(v->ArpWaitTable); } -// Check whether the MAC address is valid -bool IsMacInvalid(UCHAR *mac) -{ - UINT i; - // Validate arguments - if (mac == NULL) - { - return false; - } - - for (i = 0;i < 6;i++) - { - if (mac[i] != 0x00) - { - return false; - } - } - return true; -} - -// Check whether the MAC address is a broadcast address -bool IsMacBroadcast(UCHAR *mac) -{ - UINT i; - // Validate arguments - if (mac == NULL) - { - return false; - } - - for (i = 0;i < 6;i++) - { - if (mac[i] != 0xff) - { - return false; - } - } - return true; -} - // Insert an entry in the ARP table void InsertArpTable(VH *v, UCHAR *mac, UINT ip) { diff --git a/src/Cedar/Virtual.h b/src/Cedar/Virtual.h index 80c71463..5577e1ad 100644 --- a/src/Cedar/Virtual.h +++ b/src/Cedar/Virtual.h @@ -409,8 +409,6 @@ ARP_ENTRY *SearchArpTable(VH *v, UINT ip); void RefreshArpTable(VH *v); void PollingArpTable(VH *v); void InsertArpTable(VH *v, UCHAR *mac, UINT ip); -bool IsMacBroadcast(UCHAR *mac); -bool IsMacInvalid(UCHAR *mac); void InitArpWaitTable(VH *v); void FreeArpWaitTable(VH *v); int CompareArpWaitTable(void *p1, void *p2); diff --git a/src/Mayaqua/Network.c b/src/Mayaqua/Network.c index 14c1f325..47babba3 100644 --- a/src/Mayaqua/Network.c +++ b/src/Mayaqua/Network.c @@ -7375,6 +7375,175 @@ void CopyIP(IP *dst, IP *src) Copy(dst, src, sizeof(IP)); } +// Utility functions about IP and MAC address types +// Identify whether the IP address is a normal unicast address +bool IsValidUnicastIPAddress4(IP* ip) +{ + UINT i; + // Validate arguments + if (IsIP4(ip) == false) + { + return false; + } + + if (IsZeroIP(ip)) + { + return false; + } + + if (ip->addr[0] >= 224 && ip->addr[0] <= 239) + { + // IPv4 Multicast + return false; + } + + + /// TODO: this is kinda incorrect, but for the correct parsing we need the netmask anyway + for (i = 0; i < 4; i++) + { + if (ip->addr[i] != 255) + { + return true; + } + } + + return false; +} +bool IsValidUnicastIPAddressUINT4(UINT ip) +{ + IP a; + + UINTToIP(&a, ip); + + return IsValidUnicastIPAddress4(&a); +} + +bool IsValidUnicastIPAddress6(IP* ip) +{ + UINT ipv6Type; + + if (!IsIP6(ip)) + { + return false; + } + + if (IsZeroIP(ip)) + { + return false; + } + + ipv6Type = GetIPAddrType6(ip); + + if (!(ipv6Type & IPV6_ADDR_LOCAL_UNICAST) && + !(ipv6Type & IPV6_ADDR_GLOBAL_UNICAST)) + { + return false; + } + + return true; +} + +// Check whether the MAC address is valid +bool IsMacInvalid(UCHAR* mac) +{ + UINT i; + // Validate arguments + if (mac == NULL) + { + return false; + } + + for (i = 0; i < 6; i++) + { + if (mac[i] != 0x00) + { + return false; + } + } + return true; +} + +// Check whether the MAC address is a broadcast address +bool IsMacBroadcast(UCHAR* mac) +{ + UINT i; + // Validate arguments + if (mac == NULL) + { + return false; + } + + for (i = 0; i < 6; i++) + { + if (mac[i] != 0xff) + { + return false; + } + } + return true; +} + +// Check wether the MAC address is an IPv4 multicast or an IPv6 multicast +bool IsMacMulticast(UCHAR* mac) +{ + // Validate arguments + if (mac == NULL) + { + return false; + } + + if (mac[0] == 0x01 && + mac[1] == 0x00 && + mac[2] == 0x5e) + { + // Multicast IPv4 and other IANA multicasts + return true; + } + + if (mac[0] == 0x01) + { + // That's not a really reserved for multicast range, but it seems like anything with 0x01 is used as multicast anyway + // Remove or specify if it causes problems + return true; + } + + if (mac[0] == 0x33 && + mac[1] == 0x33) + { + // Multicast IPv6 + return true; + } + + return false; +} + +// Check wether the MAC address is a unicast one +bool IsMacUnicast(UCHAR* mac) +{ + // Validate arguments + if (mac == NULL) + { + return false; + } + + if (IsMacInvalid(mac)) + { + return false; + } + + if (IsMacBroadcast(mac)) + { + return false; + } + + if (IsMacMulticast(mac)) + { + return false; + } + + return true; +} + // Get the number of clients connected from the specified IP address UINT GetNumIpClient(IP *ip) { diff --git a/src/Mayaqua/Network.h b/src/Mayaqua/Network.h index b99f179a..22529f23 100644 --- a/src/Mayaqua/Network.h +++ b/src/Mayaqua/Network.h @@ -1302,6 +1302,15 @@ void IPAnd4(IP *dst, IP *a, IP *b); bool IsInSameNetwork4(IP *a1, IP *a2, IP *subnet); bool IsInSameNetwork4Standard(IP *a1, IP *a2); +// Utility functions about IP and MAC address types +bool IsValidUnicastIPAddress4(IP* ip); +bool IsValidUnicastIPAddressUINT4(UINT ip); +bool IsValidUnicastIPAddress6(IP* ip); +bool IsMacUnicast(UCHAR* mac); +bool IsMacBroadcast(UCHAR* mac); +bool IsMacMulticast(UCHAR* mac); +bool IsMacInvalid(UCHAR* mac); + bool ParseIpAndSubnetMask4(char *src, UINT *ip, UINT *mask); bool ParseIpAndSubnetMask46(char *src, IP *ip, IP *mask); bool ParseIpAndMask4(char *src, UINT *ip, UINT *mask); diff --git a/src/Mayaqua/TcpIp.c b/src/Mayaqua/TcpIp.c index efdd96a0..95d5257d 100644 --- a/src/Mayaqua/TcpIp.c +++ b/src/Mayaqua/TcpIp.c @@ -889,6 +889,44 @@ BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCH return ret; } +BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR* src_ip, IPV6_ADDR* target_ip, UCHAR* my_mac_address, UINT id) +{ + ICMPV6_OPTION_LIST opt; + ICMPV6_OPTION_LINK_LAYER link; + ICMPV6_ROUTER_SOLICIATION_HEADER header; + BUF *b; + BUF *b2; + BUF *ret; + + if (src_ip == NULL || target_ip == NULL || my_mac_address == NULL) + { + return NULL; + } + + Zero(&link, sizeof(link)); + Copy(link.Address, my_mac_address, 6); + + Zero(&opt, sizeof(opt)); + opt.SourceLinkLayer = &link; + + b = BuildICMPv6Options(&opt); + + Zero(&header, sizeof(header)); + + b2 = NewBuf(); + + WriteBuf(b2, &header, sizeof(header)); + WriteBufBuf(b2, b); + + ret = BuildICMPv6(src_ip, target_ip, 255, + ICMPV6_TYPE_ROUTER_SOLICIATION, 0, b2->Buf, b2->Size, id); + + FreeBuf(b); + FreeBuf(b2); + + return ret; +} + // Get the next header number from the queue UCHAR IPv6GetNextHeaderFromQueue(QUEUE *q) { @@ -1452,6 +1490,12 @@ PKT *ClonePacket(PKT *p, bool copy_data) return ret; } +// Parse the packet but without data layer except for ICMP +PKT* ParsePacketUpToICMPv6(UCHAR* buf, UINT size) +{ + return ParsePacketEx5(buf, size, false, 0, true, true, false, true); +} + // Parse the contents of the packet PKT *ParsePacket(UCHAR *buf, UINT size) { @@ -1469,7 +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); } -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); +} +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; USHORT vlan_type_id_16; @@ -1559,7 +1607,7 @@ PKT *ParsePacketEx4(UCHAR *buf, UINT size, bool no_l3, UINT vlan_type_id, bool b } // Do parse - if (ParsePacketL2Ex(p, buf, size, no_l3) == false) + if (ParsePacketL2Ex(p, buf, size, no_l3, no_l3_l4_except_icmpv6) == false) { // Parsing failure FreePacket(p); @@ -1929,7 +1977,7 @@ HTTPLOG *ParseHttpAccessLog(PKT *pkt) // Layer-2 parsing -bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3) +bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3, bool no_l3_l4_except_icmpv6) { UINT i; bool b1, b2; @@ -1994,7 +2042,7 @@ bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3) switch (type_id_16) { case MAC_PROTO_ARPV4: // ARPv4 - if (no_l3) + if (no_l3 || no_l3_l4_except_icmpv6) { return true; } @@ -2002,7 +2050,7 @@ bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3) return ParsePacketARPv4(p, buf, size); case MAC_PROTO_IPV4: // IPv4 - if (no_l3) + if (no_l3 || no_l3_l4_except_icmpv6) { return true; } @@ -2015,7 +2063,7 @@ bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3) return true; } - return ParsePacketIPv6(p, buf, size); + return ParsePacketIPv6(p, buf, size, no_l3_l4_except_icmpv6); default: // Unknown if (type_id_16 == p->VlanTypeID) @@ -2538,7 +2586,7 @@ void CloneICMPv6Options(ICMPV6_OPTION_LIST *dst, ICMPV6_OPTION_LIST *src) } // IPv6 parsing -bool ParsePacketIPv6(PKT *p, UCHAR *buf, UINT size) +bool ParsePacketIPv6(PKT *p, UCHAR *buf, UINT size, bool no_l3_l4_except_icmpv6) { // Validate arguments if (p == NULL || buf == NULL) @@ -2585,9 +2633,17 @@ bool ParsePacketIPv6(PKT *p, UCHAR *buf, UINT size) } case IP_PROTO_TCP: // TCP + if (no_l3_l4_except_icmpv6) + { + return true; + } return ParseTCP(p, buf, size); case IP_PROTO_UDP: // UDP + if (no_l3_l4_except_icmpv6) + { + return true; + } return ParseUDP(p, buf, size); default: // Unknown diff --git a/src/Mayaqua/TcpIp.h b/src/Mayaqua/TcpIp.h index 8ff4f385..89ca3a95 100644 --- a/src/Mayaqua/TcpIp.h +++ b/src/Mayaqua/TcpIp.h @@ -745,6 +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 *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* 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); void FreePacket(PKT *p); void FreePacketWithData(PKT *p); void FreePacketIPv4(PKT *p); @@ -754,7 +756,7 @@ void FreePacketUDPv4(PKT *p); void FreePacketTCPv4(PKT *p); void FreePacketICMPv4(PKT *p); void FreePacketDHCPv4(PKT *p); -bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3); +bool ParsePacketL2Ex(PKT *p, UCHAR *buf, UINT size, bool no_l3, bool no_l3_l4_except_icmpv6); bool ParsePacketARPv4(PKT *p, UCHAR *buf, UINT size); bool ParsePacketIPv4(PKT *p, UCHAR *buf, UINT size); bool ParsePacketBPDU(PKT *p, UCHAR *buf, UINT size); @@ -770,7 +772,7 @@ void FreeClonePacket(PKT *p); void CorrectChecksum(PKT *p); -bool ParsePacketIPv6(PKT *p, UCHAR *buf, UINT size); +bool ParsePacketIPv6(PKT *p, UCHAR *buf, UINT size, bool no_l3_l4_except_icmpv6); bool ParsePacketIPv6Header(IPV6_HEADER_PACKET_INFO *info, UCHAR *buf, UINT size); bool ParseIPv6ExtHeader(IPV6_HEADER_PACKET_INFO *info, UCHAR next_header, UCHAR *buf, UINT size); bool ParseICMPv6Options(ICMPV6_OPTION_LIST *o, UCHAR *buf, UINT size); @@ -786,6 +788,7 @@ BUF *BuildIPv6PacketHeader(IPV6_HEADER_PACKET_INFO *info, UINT *bytes_before_pay UCHAR IPv6GetNextHeaderFromQueue(QUEUE *q); 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 *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); bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vlan_tpid); From f627b64264e6bf99c4a12e6faf064fc08f104c34 Mon Sep 17 00:00:00 2001 From: Evengard Date: Mon, 11 May 2020 17:18:55 +0300 Subject: [PATCH 2/6] Auto formatting with AStyle --- src/Cedar/IPC.c | 142 ++++--- src/Cedar/IPC.h | 43 ++- src/Cedar/Proto_PPP.c | 130 +++---- src/Cedar/Proto_PPP.h | 2 +- src/Mayaqua/Network.c | 864 +++++++++++++++++++++++------------------- src/Mayaqua/Network.h | 20 +- src/Mayaqua/TcpIp.c | 158 ++++---- src/Mayaqua/TcpIp.h | 8 +- 8 files changed, 727 insertions(+), 640 deletions(-) diff --git a/src/Cedar/IPC.c b/src/Cedar/IPC.c index d78524be..ed80f64f 100644 --- a/src/Cedar/IPC.c +++ b/src/Cedar/IPC.c @@ -37,7 +37,7 @@ bool ParseAndExtractMsChapV2InfoFromPassword(IPC_MSCHAP_V2_AUTHINFO *d, char *pa b4 = StrToBin(t->Token[5]); 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; @@ -226,20 +226,20 @@ IPC *NewIPCByParam(CEDAR *cedar, IPC_PARAM *param, UINT *error_code) } ipc = NewIPC(cedar, param->ClientName, param->Postfix, param->HubName, - param->UserName, param->Password, error_code, ¶m->ClientIp, - param->ClientPort, ¶m->ServerIp, param->ServerPort, - param->ClientHostname, param->CryptName, - param->BridgeMode, param->Mss, NULL, param->ClientCertificate, param->Layer); + param->UserName, param->Password, error_code, ¶m->ClientIp, + param->ClientPort, ¶m->ServerIp, param->ServerPort, + param->ClientHostname, param->CryptName, + param->BridgeMode, param->Mss, NULL, param->ClientCertificate, param->Layer); return ipc; } // Start a new IPC connection 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, - char *client_hostname, char *crypt_name, - bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate, - UINT layer) + UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port, + char *client_hostname, char *crypt_name, + bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate, + UINT layer) { IPC *ipc; 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), - ipc->ConnectionName, sizeof(ipc->ConnectionName), &ipc->Policy) == false) + ipc->ConnectionName, sizeof(ipc->ConnectionName), &ipc->Policy) == false) { err = ERR_PROTOCOL_ERROR; FreePack(p); @@ -591,7 +591,7 @@ void FreeIPC(IPC *ipc) 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); 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 || - (discon_poll_tube != NULL && IsTubeConnected(discon_poll_tube) == false)) + (discon_poll_tube != NULL && IsTubeConnected(discon_poll_tube) == false)) { // Session is disconnected 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) + sizeof(dhcp) + blank_size, &magic_number, 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 = (UDP_HEADER *)(((UCHAR *)ph) + 12); @@ -1223,7 +1223,7 @@ void IPCProcessArp(IPC *ipc, BLOCK *b) void IPCAssociateOnArpTable(IPC *ipc, IP *ip, UCHAR *mac_address) { IPC_ARP *a; - // Validate arguments + // Validate arguments if (ipc == NULL || ip == NULL || IsValidUnicastIPAddress4(ip) == false || IsMacUnicast(mac_address) == false) { return; @@ -1366,7 +1366,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) ok = true; } 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; } @@ -1404,13 +1404,13 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) } else if (protocol == MAC_PROTO_IPV6) { - PKT* p = ParsePacketUpToICMPv6(b->Buf, b->Size); + PKT *p = ParsePacketUpToICMPv6(b->Buf, b->Size); if (p != NULL) { IP ip_src, ip_dst; 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_dst, &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress); @@ -1602,7 +1602,7 @@ void IPCSendIPv4(IPC *ipc, void *data, UINT size) UINT i; // Destination - for (i = 0;i < 6;i++) + for (i = 0; i < 6; i++) { dest[i] = 0xff; } @@ -1668,7 +1668,7 @@ void IPCFlushArpTableEx(IPC *ipc, UINT64 now) 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); bool b = false; @@ -1695,7 +1695,7 @@ void IPCFlushArpTableEx(IPC *ipc, UINT64 now) 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); @@ -1759,7 +1759,7 @@ void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip) arp.SrcIP = IPToUINT(&ipc->ClientIPAddress); arp.TargetIP = IPToUINT(next_ip); - for (i = 0;i < 6;i++) + for (i = 0; i < 6; i++) { tmp[i] = 0xff; } @@ -1782,7 +1782,7 @@ void IPCSendIPv4Unicast(IPC *ipc, void *data, UINT size, IP *next_ip) } // Search the ARP table -IPC_ARP *IPCSearchArpTable(LIST* arpTable, IP *ip) +IPC_ARP *IPCSearchArpTable(LIST *arpTable, IP *ip) { IPC_ARP t; IPC_ARP *a; @@ -1939,19 +1939,22 @@ BLOCK *IPCRecvL2(IPC *ipc) // IPv6 stuff // Memory management -void IPCIPv6Init(IPC* ipc) +void IPCIPv6Init(IPC *ipc) { ipc->IPv6ReceivedQueue = NewQueue(); // The NDT is basically the same as ARP Table with some slight adjustments ipc->IPv6NeighborTable = NewList(IPCCmpArpTable); ipc->IPv6RouterAdvs = NewList(NULL); + + ipc->IPv6ClientEUI = 0; + ipc->IPv6ServerEUI = 0; } -void IPCIPv6Free(IPC* ipc) +void IPCIPv6Free(IPC *ipc) { UINT 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); } @@ -1959,7 +1962,7 @@ void IPCIPv6Free(IPC* ipc) 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); } @@ -1967,7 +1970,7 @@ void IPCIPv6Free(IPC* ipc) while (true) { - BLOCK* b = GetNext(ipc->IPv6ReceivedQueue); + BLOCK *b = GetNext(ipc->IPv6ReceivedQueue); if (b == NULL) { break; @@ -1980,17 +1983,17 @@ void IPCIPv6Free(IPC* ipc) } // 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); } -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; - if (ipc == NULL || ip == NULL || - IsValidUnicastIPAddress6(ip) == false || - IsMacUnicast(mac_address) == false) + if (ipc == NULL || ip == NULL || + IsValidUnicastIPAddress6(ip) == false || + IsMacUnicast(mac_address) == false) { return; } @@ -1998,7 +2001,7 @@ void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighb addrType = GetIPAddrType6(ip); if (addrType != IPV6_ADDR_LOCAL_UNICAST && - addrType != IPV6_ADDR_GLOBAL_UNICAST) + addrType != IPV6_ADDR_GLOBAL_UNICAST) { return; } @@ -2027,14 +2030,14 @@ void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighb else { Copy(a->MacAddress, mac_address, 6); - + if (a->Resolved == false) { a->Resolved = true; a->GiveupTime = 0; while (true) { - BLOCK* b = GetNext(a->PacketQueue); + BLOCK *b = GetNext(a->PacketQueue); 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); } -void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now) +void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now) { UINT i; - LIST* o = NULL; + LIST *o = NULL; // Validate arguments if (ipc == NULL) { @@ -2071,7 +2074,7 @@ void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now) 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; if (a->Resolved && a->ExpireTime <= now) @@ -2099,7 +2102,7 @@ void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now) { for (i = 0; i < LIST_NUM(o); i++) { - IPC_ARP* a = LIST_DATA(o, i); + IPC_ARP *a = LIST_DATA(o, i); 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 -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; bool foundPrefix = false; 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) { foundPrefix = true; @@ -2127,7 +2140,7 @@ void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* mac 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); IntToSubnetMask6(&newRA->RoutedMask, recvPrefix->Prefix->SubnetLength); 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; - IPC_IPV6_ROUTER_ADVERTISEMENT* matchingRA = NULL; + IPC_IPV6_ROUTER_ADVERTISEMENT *matchingRA = NULL; bool isInPrefix = false; 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); 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 -void IPCIPv6SendRouterSolicitation(IPC* ipc) +void IPCIPv6SendRouterSolicitation(IPC *ipc) { IP senderIP; IP destIP; @@ -2170,7 +2183,7 @@ void IPCIPv6SendRouterSolicitation(IPC* ipc) IPV6_ADDR linkLocal; BUF *packet; Zero(&linkLocal, sizeof(IPV6_ADDR)); - + // Generate link local from client's EUI linkLocal.Value[0] = 0xFE; linkLocal.Value[1] = 0x80; @@ -2202,12 +2215,19 @@ void IPCIPv6SendRouterSolicitation(IPC* ipc) // The processing should populate the received RAs by itself 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 -BLOCK* IPCIPv6Recv(IPC* ipc) +BLOCK *IPCIPv6Recv(IPC *ipc) { - BLOCK* b; + BLOCK *b; // Validate arguments if (ipc == NULL) { @@ -2219,13 +2239,13 @@ BLOCK* IPCIPv6Recv(IPC* ipc) return b; } -void IPCIPv6Send(IPC* ipc, void* data, UINT size) +void IPCIPv6Send(IPC *ipc, void *data, UINT size) { IP destAddr; UINT ipv6Type; UCHAR destMac[6]; - IPV6_HEADER* header = data; - + IPV6_HEADER *header = data; + IPv6AddrToIP(&destAddr, &header->DestAddress); 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]; // Validate arguments @@ -2279,12 +2299,12 @@ void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac 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; - UCHAR* destMac = NULL; + IPC_ARP *ndtMatch; + UCHAR *destMac = NULL; IPC_IPV6_ROUTER_ADVERTISEMENT ra; - IPV6_HEADER* header = data; + IPV6_HEADER *header = data; IP srcIp; bool isLocal = false; // 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: send Neighbor Solicitations by itself and we just proxy them CHAR tmp[MAX_SIZE]; - BLOCK* blk = NewBlock(data, size, 0); + BLOCK *blk = NewBlock(data, size, 0); InsertQueue(ndtMatch->PacketQueue, blk); 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); - + return; } destMac = ndtMatch->MacAddress; diff --git a/src/Cedar/IPC.h b/src/Cedar/IPC.h index bce2cd93..02ad2e72 100644 --- a/src/Cedar/IPC.h +++ b/src/Cedar/IPC.h @@ -125,9 +125,9 @@ struct IPC UINT Layer; // IPv6 stuff - QUEUE* IPv6ReceivedQueue; // IPv6 reception queue - LIST* IPv6NeighborTable; // Neighbor Discovery Table - LIST* IPv6RouterAdvs; // Router offered prefixes + QUEUE *IPv6ReceivedQueue; // IPv6 reception queue + LIST *IPv6NeighborTable; // Neighbor Discovery Table + LIST *IPv6RouterAdvs; // Router offered prefixes UINT64 IPv6ClientEUI; // The EUI of the client (for the SLAAC autoconf) 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, - UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port, - char *client_hostname, char *crypt_name, - bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate, - UINT layer); + UINT *error_code, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port, + char *client_hostname, char *crypt_name, + bool bridge_mode, UINT mss, EAP_CLIENT *eap_client, X *client_certificate, + UINT layer); IPC *NewIPCByParam(CEDAR *cedar, IPC_PARAM *param, UINT *error_code); IPC *NewIPCBySock(CEDAR *cedar, SOCK *s, void *mac_address); void FreeIPC(IPC *ipc); @@ -173,7 +173,7 @@ IPC_ARP *IPCNewARP(IP *ip, UCHAR *mac_address); void IPCFreeARP(IPC_ARP *a); int IPCCmpArpTable(void *p1, void *p2); 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 IPCFlushArpTable(IPC *ipc); void IPCFlushArpTableEx(IPC *ipc, UINT64 now); @@ -195,22 +195,23 @@ void FreeIPCAsync(IPC_ASYNC *a); // IPv6 stuff // Memory management -void IPCIPv6Init(IPC* ipc); -void IPCIPv6Free(IPC* ipc); +void IPCIPv6Init(IPC *ipc); +void IPCIPv6Free(IPC *ipc); // NDT -void IPCIPv6AssociateOnNDT(IPC* ipc, IP* ip, UCHAR* mac_address); -void IPCIPv6AssociateOnNDTEx(IPC* ipc, IP* ip, UCHAR* mac_address, bool isNeighborAdv); -void IPCIPv6FlushNDT(IPC* ipc); -void IPCIPv6FlushNDTEx(IPC* ipc, UINT64 now); +void IPCIPv6AssociateOnNDT(IPC *ipc, IP *ip, UCHAR *mac_address); +void IPCIPv6AssociateOnNDTEx(IPC *ipc, IP *ip, UCHAR *mac_address, bool isNeighborAdv); +void IPCIPv6FlushNDT(IPC *ipc); +void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now); +bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, IP *addr); // RA -void IPCIPv6AddRouterPrefix(IPC* ipc, ICMPV6_OPTION_LIST* recvPrefix, UCHAR* macAddress, IP* ip); -bool IPCIPv6CheckUnicastFromRouterPrefix(IPC* ipc, IP* ip, IPC_IPV6_ROUTER_ADVERTISEMENT* matchedRA); -void IPCIPv6SendRouterSolicitation(IPC* ipc); +void IPCIPv6AddRouterPrefix(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip); +bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVERTISEMENT *matchedRA); +void IPCIPv6SendRouterSolicitation(IPC *ipc); // Data flow -BLOCK* IPCIPv6Recv(IPC* ipc); -void IPCIPv6Send(IPC* ipc, void* data, UINT size); -void IPCIPv6SendWithDestMacAddr(IPC* ipc, void* data, UINT size, UCHAR* dest_mac_addr); -void IPCIPv6SendUnicast(IPC* ipc, void* data, UINT size, IP* next_ip); +BLOCK *IPCIPv6Recv(IPC *ipc); +void IPCIPv6Send(IPC *ipc, void *data, UINT size); +void IPCIPv6SendWithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr); +void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip); bool ParseAndExtractMsChapV2InfoFromPassword(IPC_MSCHAP_V2_AUTHINFO *d, char *password); diff --git a/src/Cedar/Proto_PPP.c b/src/Cedar/Proto_PPP.c index 9c6be569..b165c350 100644 --- a/src/Cedar/Proto_PPP.c +++ b/src/Cedar/Proto_PPP.c @@ -53,7 +53,7 @@ void PPPThread(THREAD *thread, void *param) IPToStr(ipstr1, sizeof(ipstr1), &p->ClientIP); IPToStr(ipstr2, sizeof(ipstr2), &p->ServerIP); 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 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)) { PPP_PACKET *request = NULL; - // Removing from resend list + // Removing from resend list for (i = 0; i < LIST_NUM(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 // which means we parsed all the client requests and responses Debug("Starting PPP Authentication phase MS-CHAP v2\n"); - + lcp = BuildMSCHAP2ChallengePacket(p); if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_CHAP, lcp)) { PPPSetStatus(p, PPP_STATUS_FAIL); WHERE; } - + PPPSetStatus(p, PPP_STATUS_AUTHENTICATING); } @@ -334,7 +334,7 @@ void PPPThread(THREAD *thread, void *param) } IPCProcessL3Events(p->Ipc); - + timeBeforeLoop = Tick64(); while (true) @@ -398,7 +398,7 @@ void PPPThread(THREAD *thread, void *param) } tubes[0] = p->TubeRecv; - + if (p->PPPStatus == PPP_STATUS_NETWORK_LAYER && p->Ipc != NULL && IsIPCConnected(p->Ipc)) { r = GetNextIntervalForInterrupt(p->Ipc->Interrupt); @@ -434,7 +434,7 @@ void PPPThread(THREAD *thread, void *param) // Maximum PPP session time of the user reached inspection if (p->UserConnectionTick != 0 && p->UserConnectionTimeout != 0 && - p->UserConnectionTick + p->UserConnectionTimeout <= now) + p->UserConnectionTick + p->UserConnectionTimeout <= now) { // User connection time-out occurs PPPLog(p, "LP_USER_TIMEOUT"); @@ -864,7 +864,7 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req WHERE; 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 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; 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"); Add(c->OptionList, NewPPPOption(PPP_LCP_OPTION_AUTH, &ms_chap_v2_code, sizeof(ms_chap_v2_code))); 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); USHORT proto = Endian16(PPP_LCP_AUTH_PAP); 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"); Add(c->OptionList, NewPPPOption(PPP_LCP_OPTION_AUTH, &proto, sizeof(USHORT))); 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"); 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 if (!isAccepted) { UINT64 offer = 0; 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"); PPPLog(p, "LP_PAP_MSCHAPV2_REJECTED"); 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); Format(ret_str, sizeof(ret_str), - "S=%s", hex); + "S=%s", hex); 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); 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)); @@ -1086,11 +1086,11 @@ bool PPPProcessIPCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re PPPRejectUnsupportedPacketEx(p, pp, true); return false; } - + // We're dealing either with ACK or NACK addr = IPToUINT(&addrStruct); IPToStr(addrStr, MAX_SIZE, &addrStruct); - + if (isAccepted) { 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); break; 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; case PPP_EAP_TYPE_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: 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; 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; NegotiatedAuthProto = PPP_PROTOCOL_PAP; @@ -1338,7 +1338,7 @@ bool PPPProcessLCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) { return false; } - + if (NegotiatedAuthProto != PPP_UNSPECIFIED) { if (p->AuthProtocol == PPP_UNSPECIFIED) @@ -1346,7 +1346,7 @@ bool PPPProcessLCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) p->AuthProtocol = NegotiatedAuthProto; PPPSetStatus(p, PPP_STATUS_BEFORE_AUTH); Debug("Setting BEFORE_AUTH from REQ on LCP request parse\n"); - } + } } 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_PACKET *ret = ZeroMalloc(sizeof(PPP_PACKET)); - + Debug("Got a PAP request before we're ready for AUTH procedure!\n"); - + ret->IsControl = true; ret->Protocol = PPP_PROTOCOL_PAP; ret->Lcp = lcp; @@ -1453,9 +1453,9 @@ bool PPPProcessPAPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) UINT error_code; ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, hub, id, password, - &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, - p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, NULL, - IPC_LAYER_3); + &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, + p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, NULL, + IPC_LAYER_3); if (ipc != NULL) { @@ -1637,9 +1637,9 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) IPToStr32(wins2_str, sizeof(wins2_str), cao.WinsServer2); PPPLog(p, "LP_DHCP_INFORM_OK", - subnet_str, defgw_str, cao.DomainName, - dns1_str, dns2_str, wins1_str, wins2_str, - server_ip_str); + subnet_str, defgw_str, cao.DomainName, + dns1_str, dns2_str, wins1_str, wins2_str, + server_ip_str); } } else @@ -1690,8 +1690,8 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) t = 1; } - p->DhcpRenewInterval = (UINT64)t * (UINT64)1000; - p->DhcpNextRenewTime = Tick64() + p->DhcpRenewInterval; + p->DhcpRenewInterval = (UINT64)t * (UINT64)1000; + p->DhcpNextRenewTime = Tick64() + p->DhcpRenewInterval; if (true) { @@ -1710,9 +1710,9 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) IPToStr32(wins2_str, sizeof(wins2_str), cao.WinsServer2); PPPLog(p, "LP_DHCP_REQUEST_OK", - client_ip_str, subnet_str, defgw_str, cao.DomainName, - dns1_str, dns2_str, wins1_str, wins2_str, - server_ip_str, cao.LeaseTime); + client_ip_str, subnet_str, defgw_str, cao.DomainName, + dns1_str, dns2_str, wins1_str, wins2_str, + server_ip_str, cao.LeaseTime); } } 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 (IsValidUnicastIPAddressUINT4(p->ClientAddressOption.ClientAddress) && - p->ClientAddressOption.SubnetMask != 0 && ok) + p->ClientAddressOption.SubnetMask != 0 && ok) { // Success to determine the address 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); 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, @@ -1808,7 +1808,7 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) PPPSetIPOptionToLCP(&res, pp->Lcp, true); } - + if (PPPRejectLCPOptionsEx(p, pp, processed)) { 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); - + if (ret != NULL && ret->IsControl && ret->Lcp != 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) { if (a->IsControl && b->IsControl && - a->Lcp != NULL && b->Lcp != NULL && - 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_RESPONSE(a->Protocol, a->Lcp->Code) == PPP_CODE_IS_RESPONSE(b->Protocol, b->Lcp->Code)) + a->Lcp != NULL && b->Lcp != NULL && + 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_RESPONSE(a->Protocol, a->Lcp->Code) == PPP_CODE_IS_RESPONSE(b->Protocol, b->Lcp->Code)) { // The packet is related! 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 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), - p->MsChapV2_ClientChallenge, sizeof(p->MsChapV2_ClientChallenge)); + p->MsChapV2_ClientChallenge, sizeof(p->MsChapV2_ClientChallenge)); 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), - &eap_client_ptr, 8); + &eap_client_ptr, 8); Format(password, sizeof(password), "%s%s:%s:%s:%s:%s", - IPC_PASSWORD_MSCHAPV2_TAG, - username_tmp, - server_challenge_hex, - client_challenge_hex, - client_response_hex, - eap_client_hex); + IPC_PASSWORD_MSCHAPV2_TAG, + username_tmp, + server_challenge_hex, + client_challenge_hex, + client_response_hex, + eap_client_hex); if (p->MsChapV2_UseDoubleMsChapV2 && p->EapClient == NULL) { @@ -2673,9 +2673,9 @@ bool PPPParseMSCHAP2ResponsePacket(PPP_SESSION *p, PPP_PACKET *pp) { Debug("MSCHAPv2 creating IPC\n"); ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, hub, id, password, - &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, - p->ClientHostname, p->CryptName, false, p->AdjustMss, p->EapClient, NULL, -+ IPC_LAYER_3); + &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, + p->ClientHostname, p->CryptName, false, p->AdjustMss, p->EapClient, NULL, + + IPC_LAYER_3); 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); UCHAR ipstr[MAX_SIZE]; - + opt2->IsAccepted = true; opt2->IsSupported = true; 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); ipc = NewIPC(p->Cedar, p->ClientSoftwareName, p->Postfix, d.HubName, d.UserName, "", - &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, - p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, p->Eap_TlsCtx.ClientCert.X, - IPC_LAYER_3); + &error_code, &p->ClientIP, p->ClientPort, &p->ServerIP, p->ServerPort, + p->ClientHostname, p->CryptName, false, p->AdjustMss, NULL, p->Eap_TlsCtx.ClientCert.X, + IPC_LAYER_3); if (ipc != NULL) { @@ -3415,7 +3415,7 @@ void FreePPPSession(PPP_SESSION *p) Free(t); } - + ReleaseList(p->SentReqPacketList); for (i = 0; i < LIST_NUM(p->DelayedPackets); i++) @@ -3425,7 +3425,7 @@ void FreePPPSession(PPP_SESSION *p) Free(t); } - + ReleaseList(p->DelayedPackets); if (p->CurrentPacket != NULL) @@ -3684,7 +3684,7 @@ void GenerateNtPasswordHash(UCHAR *dst, char *password) tmp = ZeroMalloc(tmp_size); - for (i = 0;i < len;i++) + for (i = 0; i < len; i++) { tmp[i * 2] = password[i]; } @@ -3852,7 +3852,7 @@ char *MsChapV2DoBruteForce(IPC_MSCHAP_V2_AUTHINFO *d, LIST *password_list) 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 tmp[MAX_SIZE]; @@ -3864,7 +3864,7 @@ char *MsChapV2DoBruteForce(IPC_MSCHAP_V2_AUTHINFO *d, LIST *password_list) len = StrLen(tmp); max = Power(2, MIN(len, 9)); - for (j = 0;j < max;j++) + for (j = 0; j < max; j++) { SetStrCaseAccordingToBits(tmp, j); if (MsChapV2VerityPassword(d, tmp)) diff --git a/src/Cedar/Proto_PPP.h b/src/Cedar/Proto_PPP.h index 311617ba..9c261bed 100644 --- a/src/Cedar/Proto_PPP.h +++ b/src/Cedar/Proto_PPP.h @@ -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? LIST *SentReqPacketList; // Sent requests list - + PPP_PACKET *CurrentPacket; LIST *DelayedPackets; diff --git a/src/Mayaqua/Network.c b/src/Mayaqua/Network.c index 47babba3..75365d97 100644 --- a/src/Mayaqua/Network.c +++ b/src/Mayaqua/Network.c @@ -197,7 +197,7 @@ UINT64 GetDynValue(char *name) { UINT i; - for (i = 0; i < LIST_NUM(g_dyn_value_list);i++) + for (i = 0; i < LIST_NUM(g_dyn_value_list); i++) { DYN_VALUE *vv = LIST_DATA(g_dyn_value_list, i); @@ -232,7 +232,7 @@ void SetDynListValue(char *name, UINT64 value) UINT i; DYN_VALUE *v = NULL; - for (i = 0; i < LIST_NUM(g_dyn_value_list);i++) + for (i = 0; i < LIST_NUM(g_dyn_value_list); i++) { DYN_VALUE *vv = LIST_DATA(g_dyn_value_list, i); @@ -301,7 +301,7 @@ void AddDynList(BUF *b) { UINT i; - for (i = 0;i < t->NumTokens;i++) + for (i = 0; i < t->NumTokens; i++) { char *name = t->Token[i]; UINT64 v = PackGetInt64(p, name); @@ -330,7 +330,7 @@ void FreeDynList() return; } - for (i = 0;i < LIST_NUM(g_dyn_value_list);i++) + for (i = 0; i < LIST_NUM(g_dyn_value_list); i++) { DYN_VALUE *d = LIST_DATA(g_dyn_value_list, i); @@ -364,7 +364,7 @@ int GetCurrentTimezone() Zero(&tv, sizeof(tv)); Zero(&tz, sizeof(tz)); - gettimeofday(&tv, &tz); + gettimeofday(&tv, &tz); ret = tz.tz_minuteswest; @@ -515,7 +515,7 @@ bool IsMacAddressLocalInner(LIST *o, void *addr) return false; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { NIC_ENTRY *e = LIST_DATA(o, i); @@ -559,7 +559,7 @@ LIST *Win32GetNicList() return NULL; } - for (i = 0;i < al->Num;i++) + for (i = 0; i < al->Num; i++) { MS_ADAPTER *a = al->Adapters[i]; @@ -590,7 +590,7 @@ void FreeNicList(LIST *o) return; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { NIC_ENTRY *e = LIST_DATA(o, i); @@ -607,39 +607,39 @@ UINT DetectFletsType() //LIST *o = GetHostIPAddressList(); // UINT i; -/* - for (i = 0;i < LIST_NUM(o);i++) - { - IP *ip = LIST_DATA(o, i); - - if (IsIP6(ip)) + /* + for (i = 0;i < LIST_NUM(o);i++) { - char ip_str[MAX_SIZE]; + IP *ip = LIST_DATA(o, i); - IPToStr(ip_str, sizeof(ip_str), ip); - - if (IsInSameNetwork6ByStr(ip_str, "2001:c90::", "/32")) + if (IsIP6(ip)) { - // NTT East B-FLETs - ret |= FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE; - } + char ip_str[MAX_SIZE]; - if (IsInSameNetwork6ByStr(ip_str, "2408:200::", "/23")) - { - // Wrapping in network of NTT East NGN - ret |= FLETS_DETECT_TYPE_EAST_NGN_PRIVATE; - } + IPToStr(ip_str, sizeof(ip_str), ip); - if (IsInSameNetwork6ByStr(ip_str, "2001:a200::", "/23")) - { - // Wrapping in network of NTT West NGN - ret |= FLETS_DETECT_TYPE_WEST_NGN_PRIVATE; + if (IsInSameNetwork6ByStr(ip_str, "2001:c90::", "/32")) + { + // NTT East B-FLETs + ret |= FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE; + } + + if (IsInSameNetwork6ByStr(ip_str, "2408:200::", "/23")) + { + // Wrapping in network of NTT East NGN + ret |= FLETS_DETECT_TYPE_EAST_NGN_PRIVATE; + } + + if (IsInSameNetwork6ByStr(ip_str, "2001:a200::", "/23")) + { + // Wrapping in network of NTT West NGN + ret |= FLETS_DETECT_TYPE_WEST_NGN_PRIVATE; + } } } - } - FreeHostIPAddressList(o); -*/ + FreeHostIPAddressList(o); + */ return ret; } @@ -732,9 +732,9 @@ bool GetIPViaDnsProxyForJapanFlets(IP *ip_ret, char *hostname, bool ipv6, UINT t { // Send the HTTP Request Format(request_str, sizeof(request_str), - "GET " BFLETS_DNS_PROXY_PATH "?q=%s&ipv6=%u\r\n" - "\r\n", - hostname, ipv6, connect_hostname2); + "GET " BFLETS_DNS_PROXY_PATH "?q=%s&ipv6=%u\r\n" + "\r\n", + hostname, ipv6, connect_hostname2); if (SendAll(s, request_str, StrLen(request_str), true)) { @@ -895,7 +895,7 @@ BUF *QueryFileByUdpForJapanBFlets(UINT timeout, bool *cancel) ret = QueryFileByIPv6Udp(ip_list, timeout, cancel); - for (i = 0;i < LIST_NUM(ip_list);i++) + for (i = 0; i < LIST_NUM(ip_list); i++) { IP *ip = LIST_DATA(ip_list, i); @@ -1004,7 +1004,7 @@ BUF *QueryFileByIPv6Udp(LIST *ip_list, UINT timeout, bool *cancel) { // Transmission UINT i; - for (i = 0;i < LIST_NUM(ip_list);i++) + for (i = 0; i < LIST_NUM(ip_list); i++) { IP *ip = LIST_DATA(ip_list, i); UCHAR c = 'F'; @@ -1248,7 +1248,7 @@ void RUDPProcess_NatT_Recv(RUDP_STACK *r, UDPPACKET *udp) SetCurrentGlobalIP(&ip, false); RUDPGetRegisterHostNameByIP(new_hostname, - sizeof(new_hostname), &ip); + sizeof(new_hostname), &ip); Lock(r->Lock); { @@ -1601,7 +1601,7 @@ void RUDPRecvProc(RUDP_STACK *r, UDPPACKET *p) // The target session is a session which matches the client side IP address // and the key and the signature is verified UINT i; - for (i = 0; i < LIST_NUM(r->SessionList);i++) + for (i = 0; i < LIST_NUM(r->SessionList); i++) { RUDP_SESSION *s = LIST_DATA(r->SessionList, i); @@ -1646,7 +1646,7 @@ void RUDPRecvProc(RUDP_STACK *r, UDPPACKET *p) // Check the number of sessions per IP address UINT num = 0; - for (i = 0;i < LIST_NUM(r->SessionList);i++) + for (i = 0; i < LIST_NUM(r->SessionList); i++) { RUDP_SESSION *se = LIST_DATA(r->SessionList, i); @@ -1780,7 +1780,7 @@ bool RUDPIsIpInValidateList(RUDP_STACK *r, IP *ip) return true; } - for (i = 0;i < LIST_NUM(r->NatT_SourceIpList);i++) + for (i = 0; i < LIST_NUM(r->NatT_SourceIpList); i++) { RUDP_SOURCE_IP *s = (RUDP_SOURCE_IP *)LIST_DATA(r->NatT_SourceIpList, i); @@ -1797,7 +1797,7 @@ bool RUDPIsIpInValidateList(RUDP_STACK *r, IP *ip) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { RUDP_SOURCE_IP *s = (RUDP_SOURCE_IP *)LIST_DATA(o, i); @@ -1809,7 +1809,7 @@ bool RUDPIsIpInValidateList(RUDP_STACK *r, IP *ip) ReleaseList(o); } - for (i = 0;i < LIST_NUM(r->NatT_SourceIpList);i++) + for (i = 0; i < LIST_NUM(r->NatT_SourceIpList); i++) { RUDP_SOURCE_IP *s = (RUDP_SOURCE_IP *)LIST_DATA(r->NatT_SourceIpList, i); @@ -1843,7 +1843,7 @@ void RUDPAddIpToValidateList(RUDP_STACK *r, IP *ip) return; } - for (i = 0;i < LIST_NUM(r->NatT_SourceIpList);i++) + for (i = 0; i < LIST_NUM(r->NatT_SourceIpList); i++) { RUDP_SOURCE_IP *s = (RUDP_SOURCE_IP *)LIST_DATA(r->NatT_SourceIpList, i); @@ -1860,7 +1860,7 @@ void RUDPAddIpToValidateList(RUDP_STACK *r, IP *ip) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { RUDP_SOURCE_IP *s = (RUDP_SOURCE_IP *)LIST_DATA(o, i); @@ -1874,7 +1874,7 @@ void RUDPAddIpToValidateList(RUDP_STACK *r, IP *ip) sip = NULL; - for (i = 0;i < LIST_NUM(r->NatT_SourceIpList);i++) + for (i = 0; i < LIST_NUM(r->NatT_SourceIpList); i++) { RUDP_SOURCE_IP *s = (RUDP_SOURCE_IP *)LIST_DATA(r->NatT_SourceIpList, i); @@ -1938,7 +1938,7 @@ void RUDPInterruptProc(RUDP_STACK *r) Rand(init_key, SHA1_SIZE); se = RUDPNewSession(false, &r->UdpSock->LocalIP, r->UdpSock->LocalPort, - &r->TargetIp, r->TargetPort, init_key); + &r->TargetIp, r->TargetPort, init_key); IPToStr(ip_str, sizeof(ip_str), &r->TargetIp); Debug("RUDPNewSession %X %s:%u\n", se, ip_str, r->TargetPort); @@ -1954,7 +1954,7 @@ void RUDPInterruptProc(RUDP_STACK *r) } // Process for all the sessions - for (i = 0;i < LIST_NUM(r->SessionList);i++) + for (i = 0; i < LIST_NUM(r->SessionList); i++) { RUDP_SESSION *se = LIST_DATA(r->SessionList, i); @@ -1995,7 +1995,7 @@ void RUDPInterruptProc(RUDP_STACK *r) o = NULL; current_seq_no = se->LastRecvCompleteSeqNo; - for (j = 0;j < LIST_NUM(se->RecvSegmentList);j++) + for (j = 0; j < LIST_NUM(se->RecvSegmentList); j++) { RUDP_SEGMENT *s; @@ -2064,7 +2064,7 @@ void RUDPInterruptProc(RUDP_STACK *r) // Delete the segment which has been received completely if (o != NULL) { - for (j = 0;j < LIST_NUM(o);j++) + for (j = 0; j < LIST_NUM(o); j++) { RUDP_SEGMENT *s = LIST_DATA(o, j); @@ -2213,7 +2213,7 @@ void RUDPInterruptProc(RUDP_STACK *r) } seq_no_min = RUDPGetCurrentSendingMinSeqNo(se); - for (j = 0;j < LIST_NUM(se->SendSegmentList);j++) + for (j = 0; j < LIST_NUM(se->SendSegmentList); j++) { RUDP_SEGMENT *s = LIST_DATA(se->SendSegmentList, j); @@ -2364,7 +2364,7 @@ void RUDPInterruptProc(RUDP_STACK *r) // Release the disconnected sessions o = NULL; - for (i = 0;i < LIST_NUM(r->SessionList);i++) + for (i = 0; i < LIST_NUM(r->SessionList); i++) { RUDP_SESSION *se = LIST_DATA(r->SessionList, i); @@ -2380,7 +2380,7 @@ void RUDPInterruptProc(RUDP_STACK *r) } if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { RUDP_SESSION *se = LIST_DATA(o, i); @@ -2430,7 +2430,7 @@ void RUDPBulkSend(RUDP_STACK *r, RUDP_SESSION *se, void *data, UINT data_size) Copy(buf + RUDP_BULK_IV_SIZE_V2 + sizeof(UINT64), data, data_size); // Padding - for (i = 0;i < padding_size;i++) + for (i = 0; i < padding_size; i++) { buf[RUDP_BULK_IV_SIZE_V2 + sizeof(UINT64) + data_size + i] = (UCHAR)padding_size; } @@ -2468,7 +2468,7 @@ void RUDPBulkSend(RUDP_STACK *r, RUDP_SESSION *se, void *data, UINT data_size) Copy(buf + SHA1_SIZE + SHA1_SIZE + sizeof(UINT64), data, data_size); // Padding - for (i = 0;i < padding_size;i++) + for (i = 0; i < padding_size; i++) { buf[SHA1_SIZE + SHA1_SIZE + sizeof(UINT64) + data_size + i] = (UCHAR)padding_size; } @@ -2521,7 +2521,7 @@ SOCK *ListenRUDP(char *svc_name, RUDP_STACK_INTERRUPTS_PROC *proc_interrupts, RU return ListenRUDPEx(svc_name, proc_interrupts, proc_rpc_recv, param, port, no_natt_register, over_dns_mode, NULL, 0, NULL); } 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 *s; RUDP_STACK *r; @@ -3029,7 +3029,7 @@ bool RUDPProcessRecvPacket(RUDP_STACK *r, RUDP_SESSION *se, void *recv_data, UIN RUDPProcessAck2(r, se, max_ack); } - for (i = 0;i < num_ack;i++) + for (i = 0; i < num_ack; i++) { UINT64 seq = READ_UINT64(p); @@ -3141,7 +3141,7 @@ void RUDPDisconnectSession(RUDP_STACK *r, RUDP_SESSION *se, bool disconnected_by // Send 5 disconnect signals serially if to disconnect from here if (disconnected_by_you == false) { - for (i = 0;i < 5;i++) + for (i = 0; i < 5; i++) { RUDPSendSegmentNow(r, se, se->Magic_Disconnect, NULL, 0); } @@ -3343,7 +3343,7 @@ void RUDPProcessAck2(RUDP_STACK *r, RUDP_SESSION *se, UINT64 max_seq) o = NULL; - for (i = 0;i < LIST_NUM(se->SendSegmentList);i++) + for (i = 0; i < LIST_NUM(se->SendSegmentList); i++) { RUDP_SEGMENT *s = LIST_DATA(se->SendSegmentList, i); @@ -3360,7 +3360,7 @@ void RUDPProcessAck2(RUDP_STACK *r, RUDP_SESSION *se, UINT64 max_seq) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { RUDP_SEGMENT *s = LIST_DATA(o, i); @@ -3448,7 +3448,7 @@ void RUDPSendSegmentNow(RUDP_STACK *r, RUDP_SESSION *se, UINT64 seq_no, void *da Copy(iv, se->NextIv, SHA1_SIZE); p += SHA1_SIZE; - for (i = 0;i < MIN(LIST_NUM(se->ReplyAckList), RUDP_MAX_NUM_ACK);i++) + for (i = 0; i < MIN(LIST_NUM(se->ReplyAckList), RUDP_MAX_NUM_ACK); i++) { UINT64 *seq = LIST_DATA(se->ReplyAckList, i); @@ -3480,7 +3480,7 @@ void RUDPSendSegmentNow(RUDP_STACK *r, RUDP_SESSION *se, UINT64 seq_no, void *da if (o != NULL) { // ACK body - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { UINT64 *seq = LIST_DATA(o, i); @@ -3506,7 +3506,7 @@ void RUDPSendSegmentNow(RUDP_STACK *r, RUDP_SESSION *se, UINT64 seq_no, void *da padlen = Rand8(); padlen = MAX(padlen, 1); - for (i = 0;i < padlen;i++) + for (i = 0; i < padlen; i++) { *p = padlen; p++; @@ -3614,7 +3614,7 @@ void RUDPFreeSession(RUDP_SESSION *se) Debug("RUDPFreeSession %X\n", se); - for (i = 0;i < LIST_NUM(se->SendSegmentList);i++) + for (i = 0; i < LIST_NUM(se->SendSegmentList); i++) { RUDP_SEGMENT *s = LIST_DATA(se->SendSegmentList, i); @@ -3623,7 +3623,7 @@ void RUDPFreeSession(RUDP_SESSION *se) ReleaseList(se->SendSegmentList); - for (i = 0;i < LIST_NUM(se->RecvSegmentList);i++) + for (i = 0; i < LIST_NUM(se->RecvSegmentList); i++) { RUDP_SEGMENT *s = LIST_DATA(se->RecvSegmentList, i); @@ -3782,8 +3782,8 @@ void RUDPSendPacket(RUDP_STACK *r, IP *dest_ip, UINT dest_port, void *data, UINT } p = NewUdpPacket(&r->UdpSock->LocalIP, r->UdpSock->LocalPort, - dest_ip, dest_port, - Clone(data, size), size); + dest_ip, dest_port, + Clone(data, size), size); if (r->Protocol == RUDP_PROTOCOL_ICMP || r->Protocol == RUDP_PROTOCOL_DNS) { @@ -3845,8 +3845,8 @@ void RUDPMainThread(THREAD *thread, void *param) // Receive a Packet bool ok = false; UDPPACKET *p = NewUdpPacket(&ip_src, port_src, - &r->UdpSock->LocalIP, r->UdpSock->LocalPort, - Clone(r->TmpBuf, ret), ret); + &r->UdpSock->LocalIP, r->UdpSock->LocalPort, + Clone(r->TmpBuf, ret), ret); if (r->Protocol == RUDP_PROTOCOL_ICMP) { @@ -3861,13 +3861,13 @@ void RUDPMainThread(THREAD *thread, void *param) ICMP_HEADER *icmp_header = (ICMP_HEADER *)(((UCHAR *)p->Data) + ip_header_size); ICMP_ECHO *echo_header = (ICMP_ECHO *)(((UCHAR *)p->Data) + ip_header_size + sizeof(ICMP_HEADER)); - if (icmp_header->Type == ICMP_TYPE_ECHO_RESPONSE || - icmp_header->Type == (r->ServerMode ? ICMP_TYPE_INFORMATION_REQUEST : ICMP_TYPE_INFORMATION_REPLY)) + if (icmp_header->Type == ICMP_TYPE_ECHO_RESPONSE || + icmp_header->Type == (r->ServerMode ? ICMP_TYPE_INFORMATION_REQUEST : ICMP_TYPE_INFORMATION_REPLY)) { UCHAR hash[SHA1_SIZE]; Sha1(hash, ((UCHAR *)p->Data) + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE, - p->Size - (ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE)); + p->Size - (ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE)); if (Cmp(hash, ((UCHAR *)p->Data) + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO), SHA1_SIZE) == 0) { @@ -3875,7 +3875,7 @@ void RUDPMainThread(THREAD *thread, void *param) UINT new_data_size; if (r->ServerMode) { - // On the server side, the ICMP ID and the SEQ NO of received messages are treated as a source port number + // On the server side, the ICMP ID and the SEQ NO of received messages are treated as a source port number Copy(&p->SrcPort, echo_header, sizeof(UINT)); } @@ -3968,7 +3968,7 @@ void RUDPMainThread(THREAD *thread, void *param) RUDPInterruptProc(r); // Send all packets in the transmission packet list - for (i = 0;i < LIST_NUM(r->SendPacketList);i++) + for (i = 0; i < LIST_NUM(r->SendPacketList); i++) { UDPPACKET *p = LIST_DATA(r->SendPacketList, i); @@ -3990,7 +3990,7 @@ void RUDPMainThread(THREAD *thread, void *param) if (r->ServerMode) { - // On the server side, use the port number in the opponent internal data as ICMP ID and SEQ NO + // On the server side, use the port number in the opponent internal data as ICMP ID and SEQ NO Copy(icmp_echo, &p->DestPort, 4); } else @@ -4022,11 +4022,11 @@ void RUDPMainThread(THREAD *thread, void *param) { // DNS query header USHORT us = Rand16() % 65535 + 1; - static UCHAR dns_query_header_1[] = + static UCHAR dns_query_header_1[] = { 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08, }; - static UCHAR dns_query_header_2[] = + static UCHAR dns_query_header_2[] = { 0x00, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0x29, 0x10, 0x00, 0x00, 0x00, 0x80, 0x00, @@ -4192,16 +4192,16 @@ void RUDPGetRegisterHostNameByIP(char *dst, UINT size, IP *ip) StrLower(tmp); Format(dst, size, - (IsUseAlternativeHostname() ? UDP_NAT_T_SERVER_TAG_ALT : UDP_NAT_T_SERVER_TAG), - tmp[2], tmp[3]); + (IsUseAlternativeHostname() ? UDP_NAT_T_SERVER_TAG_ALT : UDP_NAT_T_SERVER_TAG), + tmp[2], tmp[3]); if (false) { Debug("Hash Src IP: %r\n" - "Hash Dst HN: %s\n", - ip, - dst); + "Hash Dst HN: %s\n", + ip, + dst); } } @@ -4584,7 +4584,7 @@ bool IsIPv6LocalNetworkAddress(IP *ip) ret = false; - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -4626,7 +4626,7 @@ bool IsIPLocalHostOrMySelf(IP *ip) return false; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -4663,7 +4663,7 @@ UINT GetHostIPAddressHash32() } b = NewBuf(); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *ip = LIST_DATA(o, i); @@ -4953,7 +4953,7 @@ LABEL_TIMEOUT: if (IsZeroIp(&result_ip) == false) { if ((sock->IPv6 == false && IsIP4(&result_ip)) || - (sock->IPv6 && IsIP6(&result_ip))) + (sock->IPv6 && IsIP6(&result_ip))) { err = RUDP_ERROR_OK; } @@ -5063,7 +5063,7 @@ LABEL_TIMEOUT: } ret = NewRUDPClientDirect(svc_name, &result_ip, result_port, error_code, remain_timeout, cancel, - sock, sock_event, 0, false); + sock, sock_event, 0, false); } if (sock_event != NULL) @@ -5351,7 +5351,7 @@ RUDP_STACK *NewRUDP(bool server_mode, char *svc_name, RUDP_STACK_INTERRUPTS_PROC } if (true - ) + ) { RUDPGetRegisterHostNameByIP(r->CurrentRegisterHostname, sizeof(r->CurrentRegisterHostname), NULL); } @@ -5363,7 +5363,7 @@ RUDP_STACK *NewRUDP(bool server_mode, char *svc_name, RUDP_STACK_INTERRUPTS_PROC } if (r->ServerMode && r->NoNatTRegister == false - ) + ) { r->IpQueryThread = NewThread(RUDPIpQueryThread, r); } @@ -5446,7 +5446,7 @@ void FreeRUDP(RUDP_STACK *r) WaitThread(r->Thread, INFINITE); ReleaseThread(r->Thread); - for (i = 0;i < LIST_NUM(r->SessionList);i++) + for (i = 0; i < LIST_NUM(r->SessionList); i++) { RUDP_SESSION *se = LIST_DATA(r->SessionList, i); @@ -5455,7 +5455,7 @@ void FreeRUDP(RUDP_STACK *r) ReleaseList(r->SessionList); - for (i = 0;i < LIST_NUM(r->SendPacketList);i++) + for (i = 0; i < LIST_NUM(r->SendPacketList); i++) { UDPPACKET *p = LIST_DATA(r->SendPacketList, i); @@ -5474,7 +5474,7 @@ void FreeRUDP(RUDP_STACK *r) ReleaseSock(s); } - for (i = 0;i < LIST_NUM(r->NatT_SourceIpList);i++) + for (i = 0; i < LIST_NUM(r->NatT_SourceIpList); i++) { RUDP_SOURCE_IP *sip = (RUDP_SOURCE_IP *)LIST_DATA(r->NatT_SourceIpList, i); @@ -5569,7 +5569,7 @@ void GetCurrentMachineIpProcessHashInternal(void *hash) if (ip_list != NULL) { UINT i; - for (i = 0;i < LIST_NUM(ip_list);i++) + for (i = 0; i < LIST_NUM(ip_list); i++) { IP *ip = LIST_DATA(ip_list, i); @@ -5656,7 +5656,7 @@ SOCK *ListenAnyPortEx2(bool local_only, bool disable_ca) { UINT i; SOCK *s; - for (i = 40000;i < 65536;i++) + for (i = 40000; i < 65536; i++) { s = ListenEx(i, local_only); if (s != NULL) @@ -5703,7 +5703,7 @@ int SslCertVerifyCallback(int preverify_ok, X509_STORE_CTX *ctx) X *tmpX = X509ToX(cert); // this only wraps cert, but we need to make a copy if (!CompareX(tmpX, clientcert->X)) { - X* copyX = CloneX(tmpX); + X *copyX = CloneX(tmpX); if (clientcert->X != NULL) { FreeX(clientcert->X); @@ -5824,7 +5824,7 @@ bool SyncSslPipe(SSL_PIPE *s) return false; } - for (i = 0;i < 2;i++) + for (i = 0; i < 2; i++) { if (SslBioSync(s->RawIn, true, false) == false) { @@ -6147,8 +6147,8 @@ bool IsIcmpApiSupported() { #ifdef OS_WIN32 if (w32net->IcmpCloseHandle != NULL && - w32net->IcmpCreateFile != NULL && - w32net->IcmpSendEcho != NULL) + w32net->IcmpCreateFile != NULL && + w32net->IcmpSendEcho != NULL) { return true; } @@ -6198,7 +6198,7 @@ ROUTE_CHANGE *Win32NewRouteChange() } if (w32net->CancelIPChangeNotify == NULL || - w32net->NotifyRouteChange == NULL) + w32net->NotifyRouteChange == NULL) { return NULL; } @@ -6265,8 +6265,8 @@ typedef struct WIN32_ACCEPT_CHECK_DATA } WIN32_ACCEPT_CHECK_DATA; int CALLBACK Win32AcceptCheckCallback(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos, - LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData, - GROUP FAR * g, DWORD_PTR dwCallbackData) + LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData, + GROUP FAR *g, DWORD_PTR dwCallbackData) { return CF_ACCEPT; } @@ -6417,7 +6417,7 @@ UINT SubnetMaskToInt6(IP *a) return 0; } - for (i = 0;i <= 128;i++) + for (i = 0; i <= 128; i++) { IP tmp; @@ -6440,7 +6440,7 @@ UINT SubnetMaskToInt4(IP *a) return 0; } - for (i = 0;i <= 32;i++) + for (i = 0; i <= 32; i++) { IP tmp; @@ -6476,7 +6476,7 @@ bool IsSubnetMask6(IP *a) return false; } - for (i = 0;i <= 128;i++) + for (i = 0; i <= 128; i++) { IP tmp; @@ -6659,9 +6659,9 @@ UINT GetIPAddrType6(IP *ip) else { if (ip->ipv6_addr[1] == 0x02 && ip->ipv6_addr[2] == 0 && ip->ipv6_addr[3] == 0 && - ip->ipv6_addr[4] == 0 && ip->ipv6_addr[5] == 0 && ip->ipv6_addr[6] == 0 && - ip->ipv6_addr[7] == 0 && ip->ipv6_addr[8] == 0 && ip->ipv6_addr[9] == 0 && - ip->ipv6_addr[10] == 0 && ip->ipv6_addr[11] == 0x01 && ip->ipv6_addr[12] == 0xff) + ip->ipv6_addr[4] == 0 && ip->ipv6_addr[5] == 0 && ip->ipv6_addr[6] == 0 && + ip->ipv6_addr[7] == 0 && ip->ipv6_addr[8] == 0 && ip->ipv6_addr[9] == 0 && + ip->ipv6_addr[10] == 0 && ip->ipv6_addr[11] == 0x01 && ip->ipv6_addr[12] == 0xff) { ret |= IPV6_ADDR_SOLICIATION_MULTICAST; } @@ -6774,7 +6774,7 @@ void IPAnd6(IP *dst, IP *a, IP *b) } ZeroIP6(dst); - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { dst->ipv6_addr[i] = a->ipv6_addr[i] & b->ipv6_addr[i]; } @@ -6790,7 +6790,7 @@ void IntToSubnetMask6(IP *ip, UINT i) ZeroIP6(&a); - for (z = 0;z < 16;z++) + for (z = 0; z < 16; z++) { if (z < j) { @@ -6853,7 +6853,7 @@ void IPToStr6Inner(char *str, IP *ip) Copy(&a, ip, sizeof(IP)); - for (i = 0;i < 8;i++) + for (i = 0; i < 8; i++) { Copy(&values[i], &a.ipv6_addr[i * 2], sizeof(USHORT)); values[i] = Endian16(values[i]); @@ -6863,7 +6863,7 @@ void IPToStr6Inner(char *str, IP *ip) zero_started_index = INFINITE; max_zero_len = 0; max_zero_start = INFINITE; - for (i = 0;i < 9;i++) + for (i = 0; i < 9; i++) { USHORT v = (i != 8 ? values[i] : 1); @@ -6897,7 +6897,7 @@ void IPToStr6Inner(char *str, IP *ip) // Format a string StrCpy(str, 0, ""); - for (i = 0;i < 8;i++) + for (i = 0; i < 8; i++) { char tmp[16]; @@ -6995,7 +6995,7 @@ bool StrToIP6(IP *ip, char *str) n = 0; - for (i = 0;i < t->NumTokens;i++) + for (i = 0; i < t->NumTokens; i++) { char *str = t->Token[i]; @@ -7153,13 +7153,13 @@ bool CheckIPItemStr6(char *str) return false; } - for (i = 0;i < len;i++) + for (i = 0; i < len; i++) { char c = str[i]; if ((c >= 'a' && c <= 'f') || - (c >= 'A' && c <= 'F') || - (c >= '0' && c <= '9')) + (c >= 'A' && c <= 'F') || + (c >= '0' && c <= '9')) { } else @@ -7307,7 +7307,7 @@ bool IPToIPv6Addr(IPV6_ADDR *addr, IP *ip) return false; } - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { addr->Value[i] = ip->ipv6_addr[i]; } @@ -7335,7 +7335,7 @@ void SetIP6(IP *ip, UCHAR *value) { UINT i; - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { ip->ipv6_addr[i] = value[i]; } @@ -7377,7 +7377,7 @@ void CopyIP(IP *dst, IP *src) // Utility functions about IP and MAC address types // Identify whether the IP address is a normal unicast address -bool IsValidUnicastIPAddress4(IP* ip) +bool IsValidUnicastIPAddress4(IP *ip) { UINT i; // Validate arguments @@ -7418,7 +7418,7 @@ bool IsValidUnicastIPAddressUINT4(UINT ip) return IsValidUnicastIPAddress4(&a); } -bool IsValidUnicastIPAddress6(IP* ip) +bool IsValidUnicastIPAddress6(IP *ip) { UINT ipv6Type; @@ -7435,7 +7435,7 @@ bool IsValidUnicastIPAddress6(IP* ip) ipv6Type = GetIPAddrType6(ip); if (!(ipv6Type & IPV6_ADDR_LOCAL_UNICAST) && - !(ipv6Type & IPV6_ADDR_GLOBAL_UNICAST)) + !(ipv6Type & IPV6_ADDR_GLOBAL_UNICAST)) { return false; } @@ -7444,7 +7444,7 @@ bool IsValidUnicastIPAddress6(IP* ip) } // Check whether the MAC address is valid -bool IsMacInvalid(UCHAR* mac) +bool IsMacInvalid(UCHAR *mac) { UINT i; // Validate arguments @@ -7464,7 +7464,7 @@ bool IsMacInvalid(UCHAR* mac) } // Check whether the MAC address is a broadcast address -bool IsMacBroadcast(UCHAR* mac) +bool IsMacBroadcast(UCHAR *mac) { UINT i; // Validate arguments @@ -7484,7 +7484,7 @@ bool IsMacBroadcast(UCHAR* mac) } // Check wether the MAC address is an IPv4 multicast or an IPv6 multicast -bool IsMacMulticast(UCHAR* mac) +bool IsMacMulticast(UCHAR *mac) { // Validate arguments if (mac == NULL) @@ -7493,8 +7493,8 @@ bool IsMacMulticast(UCHAR* mac) } if (mac[0] == 0x01 && - mac[1] == 0x00 && - mac[2] == 0x5e) + mac[1] == 0x00 && + mac[2] == 0x5e) { // Multicast IPv4 and other IANA multicasts return true; @@ -7508,7 +7508,7 @@ bool IsMacMulticast(UCHAR* mac) } if (mac[0] == 0x33 && - mac[1] == 0x33) + mac[1] == 0x33) { // Multicast IPv6 return true; @@ -7518,7 +7518,7 @@ bool IsMacMulticast(UCHAR* mac) } // Check wether the MAC address is a unicast one -bool IsMacUnicast(UCHAR* mac) +bool IsMacUnicast(UCHAR *mac) { // Validate arguments if (mac == NULL) @@ -7656,7 +7656,7 @@ void FreeIpClientList() { UINT i; - for (i = 0;i < LIST_NUM(ip_clients);i++) + for (i = 0; i < LIST_NUM(ip_clients); i++) { IP_CLIENT *c = LIST_DATA(ip_clients, i); @@ -7818,39 +7818,105 @@ UINT IntToSubnetMask32(UINT i) switch (i) { - case 0: ret = 0x00000000; break; - case 1: ret = 0x80000000; break; - case 2: ret = 0xC0000000; break; - case 3: ret = 0xE0000000; break; - case 4: ret = 0xF0000000; break; - case 5: ret = 0xF8000000; break; - case 6: ret = 0xFC000000; break; - case 7: ret = 0xFE000000; break; - case 8: ret = 0xFF000000; break; - case 9: ret = 0xFF800000; break; - case 10: ret = 0xFFC00000; break; - case 11: ret = 0xFFE00000; break; - case 12: ret = 0xFFF00000; break; - case 13: ret = 0xFFF80000; break; - case 14: ret = 0xFFFC0000; break; - case 15: ret = 0xFFFE0000; break; - case 16: ret = 0xFFFF0000; break; - case 17: ret = 0xFFFF8000; break; - case 18: ret = 0xFFFFC000; break; - case 19: ret = 0xFFFFE000; break; - case 20: ret = 0xFFFFF000; break; - case 21: ret = 0xFFFFF800; break; - case 22: ret = 0xFFFFFC00; break; - case 23: ret = 0xFFFFFE00; break; - case 24: ret = 0xFFFFFF00; break; - case 25: ret = 0xFFFFFF80; break; - case 26: ret = 0xFFFFFFC0; break; - case 27: ret = 0xFFFFFFE0; break; - case 28: ret = 0xFFFFFFF0; break; - case 29: ret = 0xFFFFFFF8; break; - case 30: ret = 0xFFFFFFFC; break; - case 31: ret = 0xFFFFFFFE; break; - case 32: ret = 0xFFFFFFFF; break; + case 0: + ret = 0x00000000; + break; + case 1: + ret = 0x80000000; + break; + case 2: + ret = 0xC0000000; + break; + case 3: + ret = 0xE0000000; + break; + case 4: + ret = 0xF0000000; + break; + case 5: + ret = 0xF8000000; + break; + case 6: + ret = 0xFC000000; + break; + case 7: + ret = 0xFE000000; + break; + case 8: + ret = 0xFF000000; + break; + case 9: + ret = 0xFF800000; + break; + case 10: + ret = 0xFFC00000; + break; + case 11: + ret = 0xFFE00000; + break; + case 12: + ret = 0xFFF00000; + break; + case 13: + ret = 0xFFF80000; + break; + case 14: + ret = 0xFFFC0000; + break; + case 15: + ret = 0xFFFE0000; + break; + case 16: + ret = 0xFFFF0000; + break; + case 17: + ret = 0xFFFF8000; + break; + case 18: + ret = 0xFFFFC000; + break; + case 19: + ret = 0xFFFFE000; + break; + case 20: + ret = 0xFFFFF000; + break; + case 21: + ret = 0xFFFFF800; + break; + case 22: + ret = 0xFFFFFC00; + break; + case 23: + ret = 0xFFFFFE00; + break; + case 24: + ret = 0xFFFFFF00; + break; + case 25: + ret = 0xFFFFFF80; + break; + case 26: + ret = 0xFFFFFFC0; + break; + case 27: + ret = 0xFFFFFFE0; + break; + case 28: + ret = 0xFFFFFFF0; + break; + case 29: + ret = 0xFFFFFFF8; + break; + case 30: + ret = 0xFFFFFFFC; + break; + case 31: + ret = 0xFFFFFFFE; + break; + case 32: + ret = 0xFFFFFFFF; + break; } if (IsLittleEndian()) @@ -8114,7 +8180,7 @@ void UnixSelect(SOCKSET *set, UINT timeout, CANCEL *c1, CANCEL *c2) // Setting the event array if (set != NULL) { - for (i = 0;i < set->NumSocket;i++) + for (i = 0; i < set->NumSocket; i++) { s = set->Sock[i]; if (s != NULL) @@ -8234,7 +8300,7 @@ void UnixSelect(SOCKSET *set, UINT timeout, CANCEL *c1, CANCEL *c2) } // Read from the pipe of sockevent - for (i = 0;i < num_sock_events;i++) + for (i = 0; i < num_sock_events; i++) { SOCK_EVENT *e = sock_events[i]; @@ -8351,7 +8417,7 @@ bool UnixWaitSockEvent(SOCK_EVENT *event, UINT timeout) num_write = 0; num_read = 0; - for (i = 0;i < LIST_NUM(event->SockList);i++) + for (i = 0; i < LIST_NUM(event->SockList); i++) { SOCK *s = LIST_DATA(event->SockList, i); @@ -8377,7 +8443,7 @@ bool UnixWaitSockEvent(SOCK_EVENT *event, UINT timeout) n = 0; - for (i = 0;i < (num_read - 1);i++) + for (i = 0; i < (num_read - 1); i++) { SOCK *s = LIST_DATA(event->SockList, i); if (s->WriteBlocked) @@ -8423,11 +8489,11 @@ void UnixSetSockEvent(SOCK_EVENT *event) } // This is a helper function for select() -int safe_fd_set(int fd, fd_set* fds, int* max_fd) { +int safe_fd_set(int fd, fd_set *fds, int *max_fd) { FD_SET(fd, fds); if (fd > *max_fd) { *max_fd = fd; - } + } return 0; } @@ -8462,14 +8528,14 @@ void UnixSelectInner(UINT num_read, UINT *reads, UINT num_write, UINT *writes, U } num_read_total = num_write_total = 0; - for (i = 0;i < num_read;i++) + for (i = 0; i < num_read; i++) { if (reads[i] != INVALID_SOCKET) { num_read_total++; } } - for (i = 0;i < num_write;i++) + for (i = 0; i < num_write; i++) { if (writes[i] != INVALID_SOCKET) { @@ -8487,7 +8553,7 @@ void UnixSelectInner(UINT num_read, UINT *reads, UINT num_write, UINT *writes, U n = 0; - for (i = 0;i < num_read;i++) + for (i = 0; i < num_read; i++) { if (reads[i] != INVALID_SOCKET) { @@ -8501,7 +8567,7 @@ void UnixSelectInner(UINT num_read, UINT *reads, UINT num_write, UINT *writes, U } } - for (i = 0;i < num_write;i++) + for (i = 0; i < num_write; i++) { if (writes[i] != INVALID_SOCKET) { @@ -8545,7 +8611,7 @@ void UnixCleanupSockEvent(SOCK_EVENT *event) return; } - for (i = 0;i < LIST_NUM(event->SockList);i++) + for (i = 0; i < LIST_NUM(event->SockList); i++) { SOCK *s = LIST_DATA(event->SockList, i); @@ -8981,7 +9047,7 @@ bool Win32GetAdapterFromGuid(void *a, char *guid) o = NewListFast(CompareIpAdapterIndexMap); - for (i = 0;i < info->NumAdapters;i++) + for (i = 0; i < info->NumAdapters; i++) { IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i]; @@ -8990,7 +9056,7 @@ bool Win32GetAdapterFromGuid(void *a, char *guid) Sort(o); - for (i = 0;i < (int)(LIST_NUM(o));i++) + for (i = 0; i < (int)(LIST_NUM(o)); i++) { IP_ADAPTER_INDEX_MAP *e = LIST_DATA(o, i); @@ -9045,7 +9111,7 @@ void Win32RenewDhcp9x(UINT if_id) o = NewListFast(CompareIpAdapterIndexMap); - for (i = 0;i < info->NumAdapters;i++) + for (i = 0; i < info->NumAdapters; i++) { IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i]; @@ -9054,7 +9120,7 @@ void Win32RenewDhcp9x(UINT if_id) Sort(o); - for (i = 0;i < (int)(LIST_NUM(o));i++) + for (i = 0; i < (int)(LIST_NUM(o)); i++) { IP_ADAPTER_INDEX_MAP *a = LIST_DATA(o, i); @@ -9101,7 +9167,7 @@ void Win32ReleaseDhcp9x(UINT if_id, bool wait) o = NewListFast(CompareIpAdapterIndexMap); - for (i = 0;i < info->NumAdapters;i++) + for (i = 0; i < info->NumAdapters; i++) { IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i]; @@ -9110,7 +9176,7 @@ void Win32ReleaseDhcp9x(UINT if_id, bool wait) Sort(o); - for (i = 0;i < (int)(LIST_NUM(o));i++) + for (i = 0; i < (int)(LIST_NUM(o)); i++) { IP_ADAPTER_INDEX_MAP *a = LIST_DATA(o, i); @@ -9179,7 +9245,7 @@ FAILED: // Search ret = 0; o = NewListFast(CompareStr); - for (i = 0;i < p->dwNumEntries;i++) + for (i = 0; i < p->dwNumEntries; i++) { MIB_IFROW *r = &p->table[i]; if (SearchStrEx(r->bDescr, tag_name, 0, false) != INFINITE) @@ -9196,7 +9262,7 @@ FAILED: // Convert to string ss = ZeroMallocFast(sizeof(char *) * (LIST_NUM(o) + 1)); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { ss[i] = LIST_DATA(o, i); } @@ -9265,7 +9331,7 @@ FAILED: // Search ret = 0; - for (i = 0;i < p->dwNumEntries;i++) + for (i = 0; i < p->dwNumEntries; i++) { MIB_IFROW *r = &p->table[i]; if (instance_name[0] != '@') @@ -9525,7 +9591,7 @@ FAILED: // Add to the list along o = NewListFast(Win32CompareRouteEntryByMetric); - for (i = 0;i < p->dwNumEntries;i++) + for (i = 0; i < p->dwNumEntries; i++) { e = ZeroMallocFast(sizeof(ROUTE_ENTRY)); Win32IpForwardRowToRouteEntry(e, &p->table[i]); @@ -9693,88 +9759,88 @@ void Win32InitSocketLibrary() if (w32net->hIpHlpApi32 != NULL) { w32net->CreateIpForwardEntry = - (DWORD (__stdcall *)(PMIB_IPFORWARDROW)) - GetProcAddress(w32net->hIpHlpApi32, "CreateIpForwardEntry"); + (DWORD (__stdcall *)(PMIB_IPFORWARDROW)) + GetProcAddress(w32net->hIpHlpApi32, "CreateIpForwardEntry"); w32net->DeleteIpForwardEntry = - (DWORD (__stdcall *)(PMIB_IPFORWARDROW)) - GetProcAddress(w32net->hIpHlpApi32, "DeleteIpForwardEntry"); + (DWORD (__stdcall *)(PMIB_IPFORWARDROW)) + GetProcAddress(w32net->hIpHlpApi32, "DeleteIpForwardEntry"); w32net->GetIfTable = - (DWORD (__stdcall *)(PMIB_IFTABLE, PULONG, BOOL)) - GetProcAddress(w32net->hIpHlpApi32, "GetIfTable"); + (DWORD (__stdcall *)(PMIB_IFTABLE, PULONG, BOOL)) + GetProcAddress(w32net->hIpHlpApi32, "GetIfTable"); w32net->GetIfTable2 = - (DWORD (__stdcall *)(void **)) - GetProcAddress(w32net->hIpHlpApi32, "GetIfTable2"); + (DWORD (__stdcall *)(void **)) + GetProcAddress(w32net->hIpHlpApi32, "GetIfTable2"); w32net->FreeMibTable = - (void (__stdcall *)(PVOID)) - GetProcAddress(w32net->hIpHlpApi32, "FreeMibTable"); + (void (__stdcall *)(PVOID)) + GetProcAddress(w32net->hIpHlpApi32, "FreeMibTable"); w32net->GetIpForwardTable = - (DWORD (__stdcall *)(PMIB_IPFORWARDTABLE, PULONG, BOOL)) - GetProcAddress(w32net->hIpHlpApi32, "GetIpForwardTable"); + (DWORD (__stdcall *)(PMIB_IPFORWARDTABLE, PULONG, BOOL)) + GetProcAddress(w32net->hIpHlpApi32, "GetIpForwardTable"); w32net->GetNetworkParams = - (DWORD (__stdcall *)(PFIXED_INFO,PULONG)) - GetProcAddress(w32net->hIpHlpApi32, "GetNetworkParams"); + (DWORD (__stdcall *)(PFIXED_INFO,PULONG)) + GetProcAddress(w32net->hIpHlpApi32, "GetNetworkParams"); w32net->GetAdaptersAddresses = - (ULONG (__stdcall *)(ULONG,ULONG,PVOID,PIP_ADAPTER_ADDRESSES,PULONG)) - GetProcAddress(w32net->hIpHlpApi32, "GetAdaptersAddresses"); + (ULONG (__stdcall *)(ULONG,ULONG,PVOID,PIP_ADAPTER_ADDRESSES,PULONG)) + GetProcAddress(w32net->hIpHlpApi32, "GetAdaptersAddresses"); w32net->IpRenewAddress = - (DWORD (__stdcall *)(PIP_ADAPTER_INDEX_MAP)) - GetProcAddress(w32net->hIpHlpApi32, "IpRenewAddress"); + (DWORD (__stdcall *)(PIP_ADAPTER_INDEX_MAP)) + GetProcAddress(w32net->hIpHlpApi32, "IpRenewAddress"); w32net->IpReleaseAddress = - (DWORD (__stdcall *)(PIP_ADAPTER_INDEX_MAP)) - GetProcAddress(w32net->hIpHlpApi32, "IpReleaseAddress"); + (DWORD (__stdcall *)(PIP_ADAPTER_INDEX_MAP)) + GetProcAddress(w32net->hIpHlpApi32, "IpReleaseAddress"); w32net->GetInterfaceInfo = - (DWORD (__stdcall *)(PIP_INTERFACE_INFO, PULONG)) - GetProcAddress(w32net->hIpHlpApi32, "GetInterfaceInfo"); + (DWORD (__stdcall *)(PIP_INTERFACE_INFO, PULONG)) + GetProcAddress(w32net->hIpHlpApi32, "GetInterfaceInfo"); w32net->GetAdaptersInfo = - (DWORD (__stdcall *)(PIP_ADAPTER_INFO, PULONG)) - GetProcAddress(w32net->hIpHlpApi32, "GetAdaptersInfo"); + (DWORD (__stdcall *)(PIP_ADAPTER_INFO, PULONG)) + GetProcAddress(w32net->hIpHlpApi32, "GetAdaptersInfo"); w32net->GetExtendedTcpTable = - (DWORD (__stdcall *)(PVOID,PDWORD,BOOL,ULONG,_TCP_TABLE_CLASS,ULONG)) - GetProcAddress(w32net->hIpHlpApi32, "GetExtendedTcpTable"); + (DWORD (__stdcall *)(PVOID,PDWORD,BOOL,ULONG,_TCP_TABLE_CLASS,ULONG)) + GetProcAddress(w32net->hIpHlpApi32, "GetExtendedTcpTable"); w32net->AllocateAndGetTcpExTableFromStack = - (DWORD (__stdcall *)(PVOID *,BOOL,HANDLE,DWORD,DWORD)) - GetProcAddress(w32net->hIpHlpApi32, "AllocateAndGetTcpExTableFromStack"); + (DWORD (__stdcall *)(PVOID *,BOOL,HANDLE,DWORD,DWORD)) + GetProcAddress(w32net->hIpHlpApi32, "AllocateAndGetTcpExTableFromStack"); w32net->GetTcpTable = - (DWORD (__stdcall *)(PMIB_TCPTABLE,PDWORD,BOOL)) - GetProcAddress(w32net->hIpHlpApi32, "GetTcpTable"); + (DWORD (__stdcall *)(PMIB_TCPTABLE,PDWORD,BOOL)) + GetProcAddress(w32net->hIpHlpApi32, "GetTcpTable"); w32net->NotifyRouteChange = - (DWORD (__stdcall *)(PHANDLE,LPOVERLAPPED)) - GetProcAddress(w32net->hIpHlpApi32, "NotifyRouteChange"); + (DWORD (__stdcall *)(PHANDLE,LPOVERLAPPED)) + GetProcAddress(w32net->hIpHlpApi32, "NotifyRouteChange"); w32net->CancelIPChangeNotify = - (BOOL (__stdcall *)(LPOVERLAPPED)) - GetProcAddress(w32net->hIpHlpApi32, "CancelIPChangeNotify"); + (BOOL (__stdcall *)(LPOVERLAPPED)) + GetProcAddress(w32net->hIpHlpApi32, "CancelIPChangeNotify"); w32net->NhpAllocateAndGetInterfaceInfoFromStack = - (DWORD (__stdcall *)(IP_INTERFACE_NAME_INFO **,PDWORD,BOOL,HANDLE,DWORD)) - GetProcAddress(w32net->hIpHlpApi32, "NhpAllocateAndGetInterfaceInfoFromStack"); + (DWORD (__stdcall *)(IP_INTERFACE_NAME_INFO **,PDWORD,BOOL,HANDLE,DWORD)) + GetProcAddress(w32net->hIpHlpApi32, "NhpAllocateAndGetInterfaceInfoFromStack"); w32net->IcmpCreateFile = - (HANDLE (__stdcall *)()) - GetProcAddress(w32net->hIpHlpApi32, "IcmpCreateFile"); + (HANDLE (__stdcall *)()) + GetProcAddress(w32net->hIpHlpApi32, "IcmpCreateFile"); w32net->IcmpCloseHandle = - (BOOL (__stdcall *)(HANDLE)) - GetProcAddress(w32net->hIpHlpApi32, "IcmpCloseHandle"); + (BOOL (__stdcall *)(HANDLE)) + GetProcAddress(w32net->hIpHlpApi32, "IcmpCloseHandle"); w32net->IcmpSendEcho = - (DWORD (__stdcall *)(HANDLE,IPAddr,LPVOID,WORD,PIP_OPTION_INFORMATION,LPVOID,DWORD,DWORD)) - GetProcAddress(w32net->hIpHlpApi32, "IcmpSendEcho"); + (DWORD (__stdcall *)(HANDLE,IPAddr,LPVOID,WORD,PIP_OPTION_INFORMATION,LPVOID,DWORD,DWORD)) + GetProcAddress(w32net->hIpHlpApi32, "IcmpSendEcho"); } if (w32net->hIcmp != NULL) @@ -9782,16 +9848,16 @@ void Win32InitSocketLibrary() if (w32net->IcmpCreateFile == NULL || w32net->IcmpCloseHandle == NULL || w32net->IcmpSendEcho == NULL) { w32net->IcmpCreateFile = - (HANDLE (__stdcall *)()) - GetProcAddress(w32net->hIcmp, "IcmpCreateFile"); + (HANDLE (__stdcall *)()) + GetProcAddress(w32net->hIcmp, "IcmpCreateFile"); w32net->IcmpCloseHandle = - (BOOL (__stdcall *)(HANDLE)) - GetProcAddress(w32net->hIcmp, "IcmpCloseHandle"); + (BOOL (__stdcall *)(HANDLE)) + GetProcAddress(w32net->hIcmp, "IcmpCloseHandle"); w32net->IcmpSendEcho = - (DWORD (__stdcall *)(HANDLE,IPAddr,LPVOID,WORD,PIP_OPTION_INFORMATION,LPVOID,DWORD,DWORD)) - GetProcAddress(w32net->hIcmp, "IcmpSendEcho"); + (DWORD (__stdcall *)(HANDLE,IPAddr,LPVOID,WORD,PIP_OPTION_INFORMATION,LPVOID,DWORD,DWORD)) + GetProcAddress(w32net->hIcmp, "IcmpSendEcho"); } } @@ -10031,7 +10097,7 @@ void Win32Select(SOCKSET *set, UINT timeout, CANCEL *c1, CANCEL *c2) // Setting the event array if (set != NULL) { - for (i = 0;i < set->NumSocket;i++) + for (i = 0; i < set->NumSocket; i++) { s = set->Sock[i]; if (s != NULL) @@ -10179,7 +10245,7 @@ void AddHostCache(IP *ip, char *hostname) o = NewListFast(NULL); - for (i = 0;i < LIST_NUM(HostCacheList);i++) + for (i = 0; i < LIST_NUM(HostCacheList); i++) { HOSTCACHE *c = LIST_DATA(HostCacheList, i); @@ -10189,7 +10255,7 @@ void AddHostCache(IP *ip, char *hostname) } } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { HOSTCACHE *c = LIST_DATA(o, i); @@ -10227,7 +10293,7 @@ void FreeHostCache() { UINT i; - for (i = 0;i < LIST_NUM(HostCacheList);i++) + for (i = 0; i < LIST_NUM(HostCacheList); i++) { HOSTCACHE *c = LIST_DATA(HostCacheList, i); @@ -10301,7 +10367,7 @@ void FreeWaitThread() } UnlockList(WaitThreadList); - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { THREAD *t = threads[i]; WaitThread(t, INFINITE); @@ -10579,8 +10645,8 @@ ROUTE_ENTRY *GetBestRouteEntryFromRouteTableEx(ROUTE_TABLE *table, IP *ip, UINT // Select routing table entry by following rule // 1. Largest subnet mask - // 2. Smallest metric value - for (i = 0;i < table->NumEntry;i++) + // 2. Smallest metric value + for (i = 0; i < table->NumEntry; i++) { ROUTE_ENTRY *e = table->Entry[i]; UINT dest, net, mask; @@ -10616,7 +10682,7 @@ ROUTE_ENTRY *GetBestRouteEntryFromRouteTableEx(ROUTE_TABLE *table, IP *ip, UINT tmp = NULL; // Search for the item with maximum score - for (i = 0;i < table->NumEntry;i++) + for (i = 0; i < table->NumEntry; i++) { ROUTE_ENTRY *e = table->Entry[i]; @@ -10773,7 +10839,7 @@ void DebugPrintRouteTable(ROUTE_TABLE *r) Debug("---- Routing Table (%u Entries) ----\n", r->NumEntry); - for (i = 0;i < r->NumEntry;i++) + for (i = 0; i < r->NumEntry; i++) { Debug(" "); @@ -10820,9 +10886,9 @@ void RouteToStr(char *str, UINT str_size, ROUTE_ENTRY *e) IPToStr(gateway_ip, sizeof(gateway_ip), &e->GatewayIP); Format(str, str_size, "%s/%s %s m=%u oif=%u if=%u lo=%u p=%u", - dest_ip, dest_mask, gateway_ip, - e->Metric, e->OldIfMetric, e->InterfaceID, - e->LocalRouting, e->PPPConnection); + dest_ip, dest_mask, gateway_ip, + e->Metric, e->OldIfMetric, e->InterfaceID, + e->LocalRouting, e->PPPConnection); } // Delete the routing table @@ -10870,7 +10936,7 @@ ROUTE_TABLE *GetRouteTable() WriteBuf(buf, &t->NumEntry, sizeof(t->NumEntry)); - for (i = 0;i < t->NumEntry;i++) + for (i = 0; i < t->NumEntry; i++) { ROUTE_ENTRY *e = t->Entry[i]; @@ -10896,7 +10962,7 @@ void FreeRouteTable(ROUTE_TABLE *t) return; } - for (i = 0;i < t->NumEntry;i++) + for (i = 0; i < t->NumEntry; i++) { Free(t->Entry[i]); } @@ -10963,7 +11029,7 @@ UINT RecvFrom(SOCK *sock, IP *src_addr, UINT *src_port, void *data, UINT size) { #ifdef OS_WIN32 if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAENETRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH || - WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEADDRNOTAVAIL || WSAGetLastError() == WSAEADDRNOTAVAIL) + WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEADDRNOTAVAIL || WSAGetLastError() == WSAEADDRNOTAVAIL) { sock->IgnoreRecvErr = true; } @@ -11047,7 +11113,7 @@ UINT RecvFrom6(SOCK *sock, IP *src_addr, UINT *src_port, void *data, UINT size) { #ifdef OS_WIN32 if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAENETRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH || - WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEADDRNOTAVAIL || WSAGetLastError() == WSAEADDRNOTAVAIL) + WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEADDRNOTAVAIL || WSAGetLastError() == WSAEADDRNOTAVAIL) { sock->IgnoreRecvErr = true; } @@ -11128,10 +11194,10 @@ UINT SendToEx(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size, } IPToInAddr(&addr.sin_addr, dest_addr); - if ((dest_addr->addr[0] == 255 && dest_addr->addr[1] == 255 && - dest_addr->addr[2] == 255 && dest_addr->addr[3] == 255) || - (dest_addr->addr[0] >= 224 && dest_addr->addr[0] <= 239) - || broadcast) + if ((dest_addr->addr[0] == 255 && dest_addr->addr[1] == 255 && + dest_addr->addr[2] == 255 && dest_addr->addr[3] == 255) || + (dest_addr->addr[0] >= 224 && dest_addr->addr[0] <= 239) + || broadcast) { if (sock->UdpBroadcast == false) { @@ -11150,7 +11216,7 @@ UINT SendToEx(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size, #ifdef OS_WIN32 if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAENETRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH || - WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEINVAL || WSAGetLastError() == WSAEADDRNOTAVAIL) + WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEINVAL || WSAGetLastError() == WSAEADDRNOTAVAIL) { sock->IgnoreSendErr = true; } @@ -11249,7 +11315,7 @@ UINT SendTo6Ex(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size, #ifdef OS_WIN32 if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAENETRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH || - WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEINVAL || WSAGetLastError() == WSAEADDRNOTAVAIL) + WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEINVAL || WSAGetLastError() == WSAEADDRNOTAVAIL) { sock->IgnoreSendErr = true; } @@ -11298,7 +11364,7 @@ SOCK *NewUDPEx2Rand(bool ipv6, IP *ip, void *rand_seed, UINT rand_seed_size, UIN num_retry = RAND_UDP_PORT_DEFAULT_NUM_RETRY; } - for (i = 0; i < (num_retry + 1);i++) + for (i = 0; i < (num_retry + 1); i++) { BUF *buf = NewBuf(); UCHAR hash[SHA1_SIZE]; @@ -11713,9 +11779,9 @@ bool RecvAllWithDiscard(SOCK *sock, UINT size, bool secure) } if (ret == SOCK_LATER) { - // I suppose that this is safe because the RecvAll() function is used only + // I suppose that this is safe because the RecvAll() function is used only // if the sock->AsyncMode == true. And the Recv() function may return - // SOCK_LATER only if the sock->AsyncMode == false. Therefore the call of + // SOCK_LATER only if the sock->AsyncMode == false. Therefore the call of // Recv() function in the RecvAll() function never returns SOCK_LATER. return false; } @@ -11757,9 +11823,9 @@ bool RecvAll(SOCK *sock, void *data, UINT size, bool secure) } if (ret == SOCK_LATER) { - // I suppose that this is safe because the RecvAll() function is used only + // I suppose that this is safe because the RecvAll() function is used only // if the sock->AsyncMode == true. And the Recv() function may return - // SOCK_LATER only if the sock->AsyncMode == false. Therefore the call of + // SOCK_LATER only if the sock->AsyncMode == false. Therefore the call of // Recv() function in the RecvAll() function never returns SOCK_LATER. return false; } @@ -11894,7 +11960,7 @@ void AddChainSslCertOnDirectory(struct ssl_ctx_st *ctx) if (dir != NULL) { - for (i = 0;i < dir->NumFiles;i++) + for (i = 0; i < dir->NumFiles; i++) { DIRENT *e = dir->File[i]; @@ -11915,7 +11981,7 @@ void AddChainSslCertOnDirectory(struct ssl_ctx_st *ctx) GetXDigest(x, hash, true); - for (j = 0;j < LIST_NUM(o);j++) + for (j = 0; j < LIST_NUM(o); j++) { UCHAR *hash2 = LIST_DATA(o, j); @@ -11940,7 +12006,7 @@ void AddChainSslCertOnDirectory(struct ssl_ctx_st *ctx) FreeDir(dir); } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { UCHAR *hash = LIST_DATA(o, i); @@ -11967,7 +12033,7 @@ bool AddChainSslCert(struct ssl_ctx_st *ctx, X *x) { if (x_copy->root_cert) { - X509_STORE* store = SSL_CTX_get_cert_store(ctx); + X509_STORE *store = SSL_CTX_get_cert_store(ctx); X509_STORE_add_cert(store, x_copy->x509); X509_free(x_copy->x509); } @@ -12013,7 +12079,7 @@ bool StartSSLEx(SOCK *sock, X *x, K *priv, UINT ssl_timeout, char *sni_hostname) return true; } if (sock->Connected == false || sock->socket == INVALID_SOCKET || - sock->ListenMode != false) + sock->ListenMode != false) { Debug("StartSSL Error: #1\n"); return false; @@ -12316,7 +12382,7 @@ void SockEnableSslLogging(SOCK *s) GetDateTimeStrMilli64ForFileName(dtstr, sizeof(dtstr), LocalTime64()); Format(tmp, sizeof(tmp), "%s__%r_%u__%r_%u", dtstr, - &s->LocalIP, s->LocalPort, &s->RemoteIP, s->RemotePort); + &s->LocalIP, s->LocalPort, &s->RemoteIP, s->RemotePort); CombinePath(dirname, sizeof(dirname), SSL_LOGGING_DIRNAME, tmp); @@ -12450,12 +12516,12 @@ UINT SecureRecv(SOCK *sock, void *data, UINT size) { if (e == SSL_ERROR_SSL #if OPENSSL_VERSION_NUMBER < 0x10100000L - && - sock->ssl->s3->send_alert[0] == SSL3_AL_FATAL && - sock->ssl->s3->send_alert[0] != sock->Ssl_Init_Async_SendAlert[0] && - sock->ssl->s3->send_alert[1] != sock->Ssl_Init_Async_SendAlert[1] + && + sock->ssl->s3->send_alert[0] == SSL3_AL_FATAL && + sock->ssl->s3->send_alert[0] != sock->Ssl_Init_Async_SendAlert[0] && + sock->ssl->s3->send_alert[1] != sock->Ssl_Init_Async_SendAlert[1] #endif - ) + ) { Debug("%s %u SSL Fatal Error on ASYNC socket !!!\n", __FILE__, __LINE__); Disconnect(sock); @@ -12540,12 +12606,12 @@ UINT SecureRecv(SOCK *sock, void *data, UINT size) { if (e == SSL_ERROR_SSL #if OPENSSL_VERSION_NUMBER < 0x10100000L - && - sock->ssl->s3->send_alert[0] == SSL3_AL_FATAL && - sock->ssl->s3->send_alert[0] != sock->Ssl_Init_Async_SendAlert[0] && - sock->ssl->s3->send_alert[1] != sock->Ssl_Init_Async_SendAlert[1] + && + sock->ssl->s3->send_alert[0] == SSL3_AL_FATAL && + sock->ssl->s3->send_alert[0] != sock->Ssl_Init_Async_SendAlert[0] && + sock->ssl->s3->send_alert[1] != sock->Ssl_Init_Async_SendAlert[1] #endif - ) + ) { Debug("%s %u SSL Fatal Error on ASYNC socket !!!\n", __FILE__, __LINE__); Disconnect(sock); @@ -12646,7 +12712,7 @@ UINT Peek(SOCK *sock, void *data, UINT size) return 0; } if (sock->Type != SOCK_TCP || sock->Connected == false || sock->ListenMode != false || - sock->socket == INVALID_SOCKET) + sock->socket == INVALID_SOCKET) { return 0; } @@ -12693,7 +12759,7 @@ UINT Recv(SOCK *sock, void *data, UINT size, bool secure) return RecvInProc(sock, data, size); } if (sock->Type != SOCK_TCP || sock->Connected == false || sock->ListenMode != false || - sock->socket == INVALID_SOCKET) + sock->socket == INVALID_SOCKET) { return 0; } @@ -12796,7 +12862,7 @@ UINT Send(SOCK *sock, void *data, UINT size, bool secure) } size = MIN(size, MAX_SEND_BUF_MEM_SIZE); if (sock->Type != SOCK_TCP || sock->Connected == false || sock->ListenMode != false || - sock->socket == INVALID_SOCKET) + sock->socket == INVALID_SOCKET) { return 0; } @@ -12945,7 +13011,7 @@ void AcceptInitEx(SOCK *s, bool no_lookup_hostname) if (disable_gethostname_by_accept == false && no_lookup_hostname == false) { if (GetHostName(tmp, sizeof(tmp), &s->RemoteIP) == false || - IsEmptyStr(tmp)) + IsEmptyStr(tmp)) { IPToStr(tmp, sizeof(tmp), &s->RemoteIP); } @@ -13491,11 +13557,11 @@ void Disconnect(SOCK *sock) if (sock->socket != INVALID_SOCKET) { // Forced disconnection flag - #ifdef SO_DONTLINGER - (void)setsockopt(sock->socket, SOL_SOCKET, SO_DONTLINGER, (char *)&true_flag, sizeof(bool)); - #else // SO_DONTLINGER - (void)setsockopt(sock->socket, SOL_SOCKET, SO_LINGER, (char *)&false_flag, sizeof(bool)); - #endif // SO_DONTLINGER +#ifdef SO_DONTLINGER + (void)setsockopt(sock->socket, SOL_SOCKET, SO_DONTLINGER, (char *)&true_flag, sizeof(bool)); +#else // SO_DONTLINGER + (void)setsockopt(sock->socket, SOL_SOCKET, SO_LINGER, (char *)&false_flag, sizeof(bool)); +#endif // SO_DONTLINGER // setsockopt(sock->socket, SOL_SOCKET, SO_REUSEADDR, (char *)&true_flag, sizeof(bool)); } @@ -13843,7 +13909,7 @@ int connect_timeout(SOCKET s, struct sockaddr *addr, int size, int timeout, bool while (true) { int ret; - + ret = connect(s, addr, size); if (ret == 0) @@ -14195,10 +14261,10 @@ void ConnectThreadForOverDnsOrIcmp(THREAD *thread, void *param) // Connecting process sock = NewRUDPClientDirect(p->SvcName, &p->Ip, - (p->RUdpProtocol == RUDP_PROTOCOL_DNS ? 53 : MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4)), - &p->NatT_ErrorCode, p->Timeout, p->CancelFlag, NULL, NULL, - (p->RUdpProtocol == RUDP_PROTOCOL_DNS ? 0 : MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4)), - (p->RUdpProtocol == RUDP_PROTOCOL_DNS ? true : false)); + (p->RUdpProtocol == RUDP_PROTOCOL_DNS ? 53 : MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4)), + &p->NatT_ErrorCode, p->Timeout, p->CancelFlag, NULL, NULL, + (p->RUdpProtocol == RUDP_PROTOCOL_DNS ? 0 : MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4)), + (p->RUdpProtocol == RUDP_PROTOCOL_DNS ? true : false)); p->Result_Nat_T_Sock = sock; p->Ok = (p->Result_Nat_T_Sock == NULL ? false : true); @@ -14323,8 +14389,8 @@ SOCK *ConnectEx4(char *hostname, UINT port, UINT timeout, bool *cancel_flag, cha StrCpy(hint_str, sizeof(hint_str), hostname + i + 1); if (StrCmpi(hint_str, "tcp") == 0 || StrCmpi(hint_str, "disable") == 0 - || StrCmpi(hint_str, "disabled") == 0 - || StrCmpi(hint_str, "no") == 0 || StrCmpi(hint_str, "none") == 0) + || StrCmpi(hint_str, "disabled") == 0 + || StrCmpi(hint_str, "no") == 0 || StrCmpi(hint_str, "none") == 0) { // Force not to use the NAT-T force_use_natt = false; @@ -14393,7 +14459,7 @@ SOCK *ConnectEx4(char *hostname, UINT port, UINT timeout, bool *cancel_flag, cha { // The connection by forcing the use of NAT-T (not to connection with normal TCP) SOCK *nat_t_sock = NewRUDPClientNatT(nat_t_svc_name, &ip4, nat_t_error_code, timeout, cancel_flag, - hint_str, hostname); + hint_str, hostname); if (nat_t_sock != NULL) { @@ -14776,10 +14842,10 @@ void AddProtocolDetailsStr(char *dst, UINT dst_size, char *str) t1 = ParseTokenWithoutNullStr(dst, " "); t2 = ParseTokenWithoutNullStr(str, " "); - for (i = 0;i < t2->NumTokens;i++) + for (i = 0; i < t2->NumTokens; i++) { bool exists = false; - for (j = 0;j < t1->NumTokens;j++) + for (j = 0; j < t1->NumTokens; j++) { if (StrCmpi(t1->Token[j], t2->Token[i]) == 0) { @@ -14970,7 +15036,7 @@ void QuerySocketInformation(SOCK *sock) // Support of the TTL value size = sizeof(DWORD); if (opt_value == 0 || - getsockopt(sock->socket, (sock->IPv6 ? IPPROTO_IPV6 : IPPROTO_IP), opt_value, (char *)&dw, &size) != 0) + getsockopt(sock->socket, (sock->IPv6 ? IPPROTO_IPV6 : IPPROTO_IP), opt_value, (char *)&dw, &size) != 0) { sock->IsTtlSupported = false; } @@ -15022,7 +15088,7 @@ bool SetTtl(SOCK *sock, UINT ttl) } if (opt_value == 0 || - setsockopt(sock->socket, (sock->IPv6 ? IPPROTO_IPV6 : IPPROTO_IP), opt_value, (char *)&dw, size) == false) + setsockopt(sock->socket, (sock->IPv6 ? IPPROTO_IPV6 : IPPROTO_IP), opt_value, (char *)&dw, size) == false) { return false; } @@ -15233,7 +15299,7 @@ UINT IPToUINT(IP *ip) } b = (UCHAR *)&value; - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { b[i] = ip->addr[i]; } @@ -15255,7 +15321,7 @@ void UINTToIP(IP *ip, UINT value) ZeroIP4(ip); b = (UCHAR *)&value; - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { ip->addr[i] = b[i]; } @@ -15275,7 +15341,7 @@ void GetMachineHostName(char *name, UINT size) GetMachineName(tmp, sizeof(tmp)); len = StrLen(tmp); - for (i = 0;i < len;i++) + for (i = 0; i < len; i++) { if (tmp[i] == '.') { @@ -15323,7 +15389,7 @@ bool GetMachineNameFromHosts(char *name, UINT size) { UINT i; - for (i = 1;i < t->NumTokens;i++) + for (i = 1; i < t->NumTokens; i++) { if (StartWith(t->Token[i], "localhost") == false) { @@ -15611,7 +15677,7 @@ bool GetNetBiosName(char *name, UINT size, IP *ip) IPToStr(name, size, ip); - for (i = 0;i < NUM_NBT_QUERYS_SEND;i++) + for (i = 0; i < NUM_NBT_QUERYS_SEND; i++) { tran_id[i] = Rand16(); } @@ -15622,7 +15688,7 @@ bool GetNetBiosName(char *name, UINT size, IP *ip) return false; } - for (j = 0;j < NUM_NBT_QUERYS_SEND;j++) + for (j = 0; j < NUM_NBT_QUERYS_SEND; j++) { Zero(&req, sizeof(req)); req.TransactionId = Endian16(tran_id[j]); @@ -15630,7 +15696,7 @@ bool GetNetBiosName(char *name, UINT size, IP *ip) req.Query[0] = 0x20; req.Query[1] = 0x43; req.Query[2] = 0x4b; - for (i = 3;i <= 32;i++) + for (i = 3; i <= 32; i++) { req.Query[i] = 0x41; } @@ -15687,7 +15753,7 @@ bool GetNetBiosName(char *name, UINT size, IP *ip) bool b = false; UINT i; USHORT id = Endian16(r->TransactionId); - for (i = 0;i < NUM_NBT_QUERYS_SEND;i++) + for (i = 0; i < NUM_NBT_QUERYS_SEND; i++) { if (id == tran_id[i]) { @@ -15700,10 +15766,10 @@ bool GetNetBiosName(char *name, UINT size, IP *ip) if (r->Flags != 0 && r->NumQuestions == 0 && r->AnswerRRs >= 1) { if (r->Response[0] == 0x20 && r->Response[1] == 0x43 && - r->Response[2] == 0x4b) + r->Response[2] == 0x4b) { if (r->Response[34] == 0x00 && r->Response[35] == 0x21 && - r->Response[36] == 0x00 && r->Response[37] == 0x01) + r->Response[36] == 0x00 && r->Response[37] == 0x01) { char *a = (char *)(&r->Response[45]); if (StrCheckLen(a, 15)) @@ -16038,7 +16104,7 @@ bool GetIP4Ex6Ex2(IP *ip, char *hostname_arg, UINT timeout, bool ipv6, bool *can } Debug("GetIP4Ex6Ex2: Worker thread quota exceeded: max=%u current=%u\n", - GetGetIpThreadMaxNum(), GetCurrentGetIpThreadNum()); + GetGetIpThreadMaxNum(), GetCurrentGetIpThreadNum()); return ret; } @@ -16049,7 +16115,7 @@ bool GetIP4Ex6Ex2(IP *ip, char *hostname_arg, UINT timeout, bool ipv6, bool *can if (spent_time != 0) { Debug("GetIP4Ex6Ex2: Waited for %u msecs to create a worker thread.\n", - spent_time); + spent_time); } timeout -= (UINT)spent_time; @@ -16120,19 +16186,19 @@ bool GetIP4Ex6Ex2(IP *ip, char *hostname_arg, UINT timeout, bool ipv6, bool *can // if I'm in the FLETs of NTT East, // try to get an IP address using the DNS proxy server if ((flets_type & FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE) && - GetIPViaDnsProxyForJapanFlets(ip, hostname, true, 0, cancel, NULL)) + GetIPViaDnsProxyForJapanFlets(ip, hostname, true, 0, cancel, NULL)) { // B FLETs ret = true; } else if ((flets_type & FLETS_DETECT_TYPE_EAST_NGN_PRIVATE) && - GetIPViaDnsProxyForJapanFlets(ip, hostname, true, 0, cancel, FLETS_NGN_EAST_DNS_PROXY_HOSTNAME)) + GetIPViaDnsProxyForJapanFlets(ip, hostname, true, 0, cancel, FLETS_NGN_EAST_DNS_PROXY_HOSTNAME)) { // FLET'S Hikar-Next (NTT East) ret = true; } else if ((flets_type & FLETS_DETECT_TYPE_WEST_NGN_PRIVATE) && - GetIPViaDnsProxyForJapanFlets(ip, hostname, true, 0, cancel, FLETS_NGN_WEST_DNS_PROXY_HOSTNAME)) + GetIPViaDnsProxyForJapanFlets(ip, hostname, true, 0, cancel, FLETS_NGN_WEST_DNS_PROXY_HOSTNAME)) { // FLET'S Hikar-Next (NTT West) ret = true; @@ -16220,7 +16286,7 @@ bool GetIP6Inner(IP *ip, char *hostname) info = NULL; if (getaddrinfo(hostname, NULL, &hint, &info) != 0 || - info->ai_family != AF_INET6) + info->ai_family != AF_INET6) { if (info) { @@ -16274,7 +16340,7 @@ bool GetIP4Inner(IP *ip, char *hostname) info = NULL; if (getaddrinfo(hostname, NULL, &hint, &info) != 0 || - info->ai_family != AF_INET) + info->ai_family != AF_INET) { if (info) { @@ -16445,18 +16511,18 @@ bool StrToIP(IP *ip, char *str) FreeToken(token); return false; } - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { char *s = token->Token[i]; if (s[0] < '0' || s[0] > '9' || - (ToInt(s) >= 256)) + (ToInt(s) >= 256)) { FreeToken(token); return false; } } Zero(ip, sizeof(IP)); - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { ip->addr[i] = (UCHAR)ToInt(token->Token[i]); } @@ -16507,7 +16573,7 @@ void IPToInAddr(struct in_addr *addr, IP *ip) if (IsIP6(ip) == false) { - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { ((UCHAR *)addr)[i] = ip->addr[i]; } @@ -16528,7 +16594,7 @@ void IPToInAddr6(struct in6_addr *addr, IP *ip) if (IsIP6(ip)) { - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { ((UCHAR *)addr)[i] = ip->ipv6_addr[i]; } @@ -16547,7 +16613,7 @@ void InAddrToIP(IP *ip, struct in_addr *addr) Zero(ip, sizeof(IP)); - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { ip->addr[i] = ((UCHAR *)addr)[i]; } @@ -16564,7 +16630,7 @@ void InAddrToIP6(IP *ip, struct in6_addr *addr) } ZeroIP6(ip); - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { ip->ipv6_addr[i] = ((UCHAR *)addr)[i]; } @@ -16697,7 +16763,7 @@ void FreeDnsCache() { DNSCACHE *c; UINT i; - for (i = 0;i < LIST_NUM(DnsCache);i++) + for (i = 0; i < LIST_NUM(DnsCache); i++) { // Release the memory for the entry c = LIST_DATA(DnsCache, i); @@ -16994,7 +17060,7 @@ bool IsIPMyHost(IP *ip) // Search to check whether it matches to any of the IP of the local host o = GetHostIPAddressList(); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -17130,7 +17196,7 @@ bool IsOnPrivateIPFile(UINT ip) LIST *o = g_private_ip_list; UINT i; - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { PRIVATE_IP_SUBNET *p = LIST_DATA(o, i); @@ -17154,7 +17220,7 @@ void FreePrivateIPFile() g_private_ip_list = NULL; - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { PRIVATE_IP_SUBNET *p = LIST_DATA(o, i); @@ -17183,7 +17249,7 @@ bool IsIPAddressInSameLocalNetwork(IP *a) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -17224,7 +17290,7 @@ void GetCurrentGlobalIPGuess(IP *ip, bool ipv6) if (ipv6 == false) { // IPv4 - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -17239,7 +17305,7 @@ void GetCurrentGlobalIPGuess(IP *ip, bool ipv6) if (IsZeroIp(ip)) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -17261,7 +17327,7 @@ void GetCurrentGlobalIPGuess(IP *ip, bool ipv6) else { // IPv6 - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *p = LIST_DATA(o, i); @@ -17337,7 +17403,7 @@ void FreeNetwork() DeleteLock(machine_ip_process_hash_lock); machine_name_lock = NULL; ssl_accept_lock = machine_name_lock = disconnect_function_lock = - aho = socket_library_lock = ssl_connect_lock = machine_ip_process_hash_lock = NULL; + aho = socket_library_lock = ssl_connect_lock = machine_ip_process_hash_lock = NULL; // Release of the DNS cache FreeDnsCache(); @@ -17408,7 +17474,7 @@ void StopSockList(SOCKLIST *sl) } UnlockList(sl->SockList); - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { SOCK *s = ss[i]; @@ -17474,7 +17540,7 @@ SOCKET_TIMEOUT_PARAM *NewSocketTimeout(SOCK *sock) { // Debug("NewSockTimeout(%u)\n",sock->TimeOut); - ttp = (SOCKET_TIMEOUT_PARAM*)Malloc(sizeof(SOCKET_TIMEOUT_PARAM)); + ttp = (SOCKET_TIMEOUT_PARAM *)Malloc(sizeof(SOCKET_TIMEOUT_PARAM)); // Set the parameters of the time-out thread ttp->cancel = NewCancel(); @@ -18306,7 +18372,7 @@ void FreeHostIPAddressList(LIST *o) return; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *ip = LIST_DATA(o, i); @@ -18330,7 +18396,7 @@ bool IsMyIPAddress(IP *ip) o = GetHostIPAddressList(); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *a = LIST_DATA(o, i); @@ -18442,7 +18508,7 @@ UINT64 GetHostIPAddressListHash() if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *ip = LIST_DATA(o, i); char tmp[128]; @@ -18483,8 +18549,8 @@ LIST *GetHostIPAddressList() UINT64 now = Tick64(); if (host_ip_address_list_cache_last == 0 || - ((host_ip_address_list_cache_last + (UINT64)HOST_IP_ADDRESS_LIST_CACHE) < now) || - host_ip_address_cache == NULL) + ((host_ip_address_list_cache_last + (UINT64)HOST_IP_ADDRESS_LIST_CACHE) < now) || + host_ip_address_cache == NULL) { if (host_ip_address_cache != NULL) { @@ -18521,7 +18587,7 @@ LIST *CloneIPAddressList(LIST *o) ret = NewListFast(CmpIpAddressList); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP *ip = LIST_DATA(o, i); @@ -18665,30 +18731,30 @@ LIST *GetHostIPAddressListInternal() { if (a->ifa_addr != NULL) { - struct sockaddr *addr = a->ifa_addr; + struct sockaddr *addr = a->ifa_addr; - if (addr->sa_family == AF_INET) - { - IP ip; - struct sockaddr_in *d = (struct sockaddr_in *)addr; - struct in_addr *addr = &d->sin_addr; + if (addr->sa_family == AF_INET) + { + IP ip; + struct sockaddr_in *d = (struct sockaddr_in *)addr; + struct in_addr *addr = &d->sin_addr; - InAddrToIP(&ip, addr); + InAddrToIP(&ip, addr); - AddHostIPAddressToList(o, &ip); - } - else if (addr->sa_family == AF_INET6) - { - IP ip; - struct sockaddr_in6 *d = (struct sockaddr_in6 *)addr; - UINT scope_id = d->sin6_scope_id; - struct in6_addr *addr = &d->sin6_addr; + AddHostIPAddressToList(o, &ip); + } + else if (addr->sa_family == AF_INET6) + { + IP ip; + struct sockaddr_in6 *d = (struct sockaddr_in6 *)addr; + UINT scope_id = d->sin6_scope_id; + struct in6_addr *addr = &d->sin6_addr; - InAddrToIP6(&ip, addr); - ip.ipv6_scope_id = scope_id; + InAddrToIP6(&ip, addr); + ip.ipv6_scope_id = scope_id; - AddHostIPAddressToList(o, &ip); - } + AddHostIPAddressToList(o, &ip); + } } a = a->ifa_next; @@ -18714,7 +18780,7 @@ bool IsUdpPortOpened(UDPLISTENER *u, IP *server_ip, UINT port) if (server_ip != NULL) { - for (i = 0;i < LIST_NUM(u->SockList);i++) + for (i = 0; i < LIST_NUM(u->SockList); i++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i); @@ -18731,7 +18797,7 @@ bool IsUdpPortOpened(UDPLISTENER *u, IP *server_ip, UINT port) } } - for (i = 0;i < LIST_NUM(u->SockList);i++) + for (i = 0; i < LIST_NUM(u->SockList); i++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i); @@ -18914,7 +18980,7 @@ void UdpListenerThread(THREAD *thread, void *param) LockList(u->PortList); { - for (k = 0;k < LIST_NUM(u->SockList);k++) + for (k = 0; k < LIST_NUM(u->SockList); k++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k); @@ -18922,7 +18988,7 @@ void UdpListenerThread(THREAD *thread, void *param) } // If the combination of the IP address and the port number doesn't exist in the list, add it to the list - for (i = 0;i < LIST_NUM(iplist);i++) + for (i = 0; i < LIST_NUM(iplist); i++) { IP *ip = LIST_DATA(iplist, i); @@ -18933,7 +18999,7 @@ void UdpListenerThread(THREAD *thread, void *param) WriteBuf(ip_list_buf_new, ip, sizeof(IP)); - for (j = 0;j < LIST_NUM(u->PortList);j++) + for (j = 0; j < LIST_NUM(u->PortList); j++) { UINT k; UINT *port = LIST_DATA(u->PortList, j); @@ -18945,7 +19011,7 @@ void UdpListenerThread(THREAD *thread, void *param) } - for (k = 0;k < LIST_NUM(u->SockList);k++) + for (k = 0; k < LIST_NUM(u->SockList); k++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k); @@ -18975,7 +19041,7 @@ void UdpListenerThread(THREAD *thread, void *param) // If any errors suspected or the combination of IP address and port number // has been regarded to delete already, delete it - for (k = 0;k < LIST_NUM(u->SockList);k++) + for (k = 0; k < LIST_NUM(u->SockList); k++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k); @@ -18986,7 +19052,7 @@ void UdpListenerThread(THREAD *thread, void *param) } } - for (i = 0;i < LIST_NUM(del_us_list);i++) + for (i = 0; i < LIST_NUM(del_us_list); i++) { UDPLISTENER_SOCK *us = LIST_DATA(del_us_list, i); @@ -19009,7 +19075,7 @@ void UdpListenerThread(THREAD *thread, void *param) UnlockList(u->PortList); // Open the UDP sockets which is not opend yet - for (k = 0;k < LIST_NUM(u->SockList);k++) + for (k = 0; k < LIST_NUM(u->SockList); k++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k); @@ -19085,7 +19151,7 @@ LABEL_RESTART: } // Receive the data that is arriving at the socket - for (k = 0;k < LIST_NUM(u->SockList);k++) + for (k = 0; k < LIST_NUM(u->SockList); k++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k); @@ -19101,7 +19167,7 @@ LABEL_RESTART: us->NextMyIpAndPortPollTick = now + (UINT64)GenRandInterval(UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MIN, UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MAX); if (IsZeroIP(&nat_t_ip) == false - ) + ) { UCHAR c = 'A'; @@ -19161,7 +19227,7 @@ LABEL_FATAL_ERROR: { // Receive a regular packet p = NewUdpPacket(&src_addr, src_port, &us->Sock->LocalIP, us->Sock->LocalPort, - Clone(buf, size), size); + Clone(buf, size), size); if (p->SrcPort == MAKE_SPECIAL_PORT(52)) { @@ -19181,8 +19247,8 @@ LABEL_FATAL_ERROR: // Pass the received packet to the procedure u->RecvProc(u, recv_list); - // Release the packet - for (i = 0;i < LIST_NUM(recv_list);i++) + // Release the packet + for (i = 0; i < LIST_NUM(recv_list); i++) { UDPPACKET *p = LIST_DATA(recv_list, i); @@ -19205,7 +19271,7 @@ LABEL_FATAL_ERROR: Zero(&last_src_ip, sizeof(IP)); last_src_port = 0; - for (i = 0;i < LIST_NUM(u->SendPacketList);i++) + for (i = 0; i < LIST_NUM(u->SendPacketList); i++) { UDPPACKET *p = LIST_DATA(u->SendPacketList, i); UDPLISTENER_SOCK *us; @@ -19293,7 +19359,7 @@ LABEL_FATAL_ERROR: } // Release of the socket list - for (i = 0;i < LIST_NUM(u->SockList);i++) + for (i = 0; i < LIST_NUM(u->SockList); i++) { UDPLISTENER_SOCK *us = (UDPLISTENER_SOCK *)LIST_DATA(u->SockList, i); @@ -19319,7 +19385,7 @@ UDPLISTENER_SOCK *DetermineUdpSocketForSending(UDPLISTENER *u, UDPPACKET *p) return NULL; } - for (i = 0;i < LIST_NUM(u->SockList);i++) + for (i = 0; i < LIST_NUM(u->SockList); i++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i); @@ -19335,7 +19401,7 @@ UDPLISTENER_SOCK *DetermineUdpSocketForSending(UDPLISTENER *u, UDPPACKET *p) } } - for (i = 0;i < LIST_NUM(u->SockList);i++) + for (i = 0; i < LIST_NUM(u->SockList); i++) { UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i); @@ -19346,7 +19412,7 @@ UDPLISTENER_SOCK *DetermineUdpSocketForSending(UDPLISTENER *u, UDPPACKET *p) if (IsZeroIP(&us->IpAddress)) { if ((IsIP4(&p->DstIP) && IsIP4(&us->IpAddress)) || - (IsIP6(&p->DstIP) && IsIP6(&us->IpAddress))) + (IsIP6(&p->DstIP) && IsIP6(&us->IpAddress))) { return us; } @@ -19445,7 +19511,7 @@ void UdpListenerSendPackets(UDPLISTENER *u, LIST *packet_list) num = LIST_NUM(packet_list); - for (i = 0;i < LIST_NUM(packet_list);i++) + for (i = 0; i < LIST_NUM(packet_list); i++) { UDPPACKET *p = LIST_DATA(packet_list, i); @@ -19474,7 +19540,7 @@ UDPLISTENER *NewUdpListenerEx(UDPLISTENER_RECV_PROC *recv_proc, void *param, IP { return NULL; } - + u = ZeroMalloc(sizeof(UDPLISTENER)); u->Param = param; @@ -19528,7 +19594,7 @@ void FreeUdpListener(UDPLISTENER *u) ReleaseIntList(u->PortList); - for (i = 0;i < LIST_NUM(u->SendPacketList);i++) + for (i = 0; i < LIST_NUM(u->SendPacketList); i++) { UDPPACKET *p = LIST_DATA(u->SendPacketList, i); @@ -19575,12 +19641,12 @@ void DeleteAllPortFromUdpListener(UDPLISTENER *u) UINT *ports = ZeroMalloc(sizeof(UINT) * num_ports); UINT i; - for (i = 0;i < num_ports;i++) + for (i = 0; i < num_ports; i++) { ports[i] = *((UINT *)(LIST_DATA(u->PortList, i))); } - for (i = 0;i < num_ports;i++) + for (i = 0; i < num_ports; i++) { UINT port = ports[i]; @@ -19662,7 +19728,7 @@ void FreeInterruptManager(INTERRUPT_MANAGER *m) return; } - for (i = 0;i < LIST_NUM(m->TickList);i++) + for (i = 0; i < LIST_NUM(m->TickList); i++) { UINT64 *v = LIST_DATA(m->TickList, i); @@ -19709,7 +19775,7 @@ UINT GetNextIntervalForInterrupt(INTERRUPT_MANAGER *m) LockList(m->TickList); { // Remove entries older than now already - for (i = 0;i < LIST_NUM(m->TickList);i++) + for (i = 0; i < LIST_NUM(m->TickList); i++) { UINT64 *v = LIST_DATA(m->TickList, i); @@ -19730,7 +19796,7 @@ UINT GetNextIntervalForInterrupt(INTERRUPT_MANAGER *m) } } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { UINT64 *v = LIST_DATA(o, i); @@ -20140,7 +20206,7 @@ UINT RecvInProc(SOCK *sock, void *data, UINT size) } else { - // If a timeout occurs in asynchronous mode, returns the blocking error + // If a timeout occurs in asynchronous mode, returns the blocking error return SOCK_LATER; } } @@ -20198,7 +20264,7 @@ void Win32WaitForTubes(TUBE **tubes, UINT num, UINT timeout) Zero(array, sizeof(array)); - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { TUBE *t = tubes[i]; @@ -20224,7 +20290,7 @@ void UnixWaitForTubes(TUBE **tubes, UINT num, UINT timeout) fds = ZeroMalloc(sizeof(int) * num); - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { fds[i] = tubes[i]->SockEvent->pipe_read; @@ -20239,7 +20305,7 @@ void UnixWaitForTubes(TUBE **tubes, UINT num, UINT timeout) UnixSelectInner(num, fds, 0, NULL, timeout); } - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { int fd = fds[i]; int readret; @@ -20277,7 +20343,7 @@ void FreeTubeFlushList(TUBE_FLUSH_LIST *f) return; } - for (i = 0;i < LIST_NUM(f->List);i++) + for (i = 0; i < LIST_NUM(f->List); i++) { TUBE *t = LIST_DATA(f->List, i); @@ -20323,7 +20389,7 @@ void FlushTubeFlushList(TUBE_FLUSH_LIST *f) return; } - for (i = 0;i < LIST_NUM(f->List);i++) + for (i = 0; i < LIST_NUM(f->List); i++) { TUBE *t = LIST_DATA(f->List, i); @@ -20585,8 +20651,8 @@ bool GetSniNameFromSslPacket(UCHAR *packet_buf, UINT packet_size, char *sni, UIN } if (!(packet_buf[0] == 0x16 && packet_buf[1] >= 0x03 && - packet_buf[5] == 0x01 && packet_buf[6] == 0x00 && - packet_buf[9] >= 0x03)) + packet_buf[5] == 0x01 && packet_buf[6] == 0x00 && + packet_buf[9] >= 0x03)) { return false; } @@ -20594,8 +20660,8 @@ bool GetSniNameFromSslPacket(UCHAR *packet_buf, UINT packet_size, char *sni, UIN buf = NewBufFromMemory(packet_buf, packet_size); if (ReadBuf(buf, &content_type, sizeof(UCHAR)) == sizeof(UCHAR) && - ReadBuf(buf, &version, sizeof(USHORT)) == sizeof(USHORT) && - ReadBuf(buf, &handshake_length, sizeof(USHORT)) == sizeof(USHORT)) + ReadBuf(buf, &version, sizeof(USHORT)) == sizeof(USHORT) && + ReadBuf(buf, &handshake_length, sizeof(USHORT)) == sizeof(USHORT)) { version = Endian16(version); handshake_length = Endian16(handshake_length); @@ -20611,7 +20677,7 @@ bool GetSniNameFromSslPacket(UCHAR *packet_buf, UINT packet_size, char *sni, UIN USHORT handshake_length_2; if (ReadBuf(buf2, &handshake_type, sizeof(USHORT)) == sizeof(USHORT) && - ReadBuf(buf2, &handshake_length_2, sizeof(USHORT)) == sizeof(USHORT)) + ReadBuf(buf2, &handshake_length_2, sizeof(USHORT)) == sizeof(USHORT)) { handshake_type = Endian16(handshake_type); handshake_length_2 = Endian16(handshake_length_2); @@ -20777,11 +20843,11 @@ bool GetSniNameFromSslPacket(UCHAR *packet_buf, UINT packet_size, char *sni, UIN } void SetDhParam(DH_CTX *dh) - { +{ if (dh_param) { - DhFree(dh_param); - } + DhFree(dh_param); + } - dh_param = dh; - } + dh_param = dh; +} diff --git a/src/Mayaqua/Network.h b/src/Mayaqua/Network.h index 22529f23..90b5e95c 100644 --- a/src/Mayaqua/Network.h +++ b/src/Mayaqua/Network.h @@ -357,7 +357,7 @@ typedef struct SOCKLIST // Parameters for timeout thread for Solaris -typedef struct SOCKET_TIMEOUT_PARAM{ +typedef struct SOCKET_TIMEOUT_PARAM { SOCK *sock; CANCEL *cancel; THREAD *thread; @@ -651,7 +651,7 @@ struct RUDP_SESSION UINT64 Magic_Disconnect; // Disconnection Signal UINT64 NextSendSeqNo; // Transmission sequence number to be used next 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 UINT NextKeepAliveInterval; // Interval value of KeepAlive to be used next FIFO *RecvFifo; // Reception FIFO @@ -846,7 +846,7 @@ struct CONNECT_TCP_RUDP_PARAM #define SSL_DEFAULT_CONNECT_TIMEOUT (15 * 1000) // SSL default timeout -// Header for TCP Pair +// Header for TCP Pair struct TCP_PAIR_HEADER { bool EnableHMac; @@ -949,7 +949,7 @@ UINT64 RUDPGetCurrentSendingMinSeqNo(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 *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); void *InitWaitUntilHostIPAddressChanged(); void FreeWaitUntilHostIPAddressChanged(void *p); @@ -1303,13 +1303,13 @@ bool IsInSameNetwork4(IP *a1, IP *a2, IP *subnet); bool IsInSameNetwork4Standard(IP *a1, IP *a2); // Utility functions about IP and MAC address types -bool IsValidUnicastIPAddress4(IP* ip); +bool IsValidUnicastIPAddress4(IP *ip); bool IsValidUnicastIPAddressUINT4(UINT ip); -bool IsValidUnicastIPAddress6(IP* ip); -bool IsMacUnicast(UCHAR* mac); -bool IsMacBroadcast(UCHAR* mac); -bool IsMacMulticast(UCHAR* mac); -bool IsMacInvalid(UCHAR* mac); +bool IsValidUnicastIPAddress6(IP *ip); +bool IsMacUnicast(UCHAR *mac); +bool IsMacBroadcast(UCHAR *mac); +bool IsMacMulticast(UCHAR *mac); +bool IsMacInvalid(UCHAR *mac); bool ParseIpAndSubnetMask4(char *src, UINT *ip, UINT *mask); bool ParseIpAndSubnetMask46(char *src, IP *ip, IP *mask); diff --git a/src/Mayaqua/TcpIp.c b/src/Mayaqua/TcpIp.c index 95d5257d..36849716 100644 --- a/src/Mayaqua/TcpIp.c +++ b/src/Mayaqua/TcpIp.c @@ -84,7 +84,7 @@ ICMP_RESULT *IcmpParseResult(IP *dest_ip, USHORT src_id, USHORT src_seqno, UCHAR ret->Ttl = ipv4->TimeToLive; 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->DataSize); + ret->DataSize); 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->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->DataSize); + ret->DataSize); 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) || - ((tcp->Flag & TCP_RST) || - (tcp->Flag & TCP_PSH) || - (tcp->Flag & TCP_URG))) + ((tcp->Flag & TCP_RST) || + (tcp->Flag & TCP_PSH) || + (tcp->Flag & TCP_URG))) { // Not a SYN packet return false; @@ -591,7 +591,7 @@ bool AdjustTcpMssL3(UCHAR *src, UINT src_size, UINT mss) { // Calculate the TCPv6 checksum tcp->Checksum = CalcChecksumForIPv6(&ip6->SrcAddress, &ip6->DestAddress, - IP_PROTO_TCP, tcp, tcp_size, 0); + IP_PROTO_TCP, tcp, tcp_size, 0); } return true; @@ -736,7 +736,7 @@ void VLanInsertTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vla USHORT vlan_tpid_ushort; // Validate arguments if (packet_data == NULL || *packet_data == NULL || packet_size == NULL || - *packet_size < 14 || vlan_id == 0) + *packet_size < 14 || vlan_id == 0) { return; } @@ -774,7 +774,7 @@ bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vla UCHAR *vlan_tpid_uchar; // Validate arguments if (packet_data == NULL || *packet_data == NULL || packet_size == NULL || - *packet_size < 14) + *packet_size < 14) { 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 i; - for (i = 12;i < dest_size;i++) + for (i = 12; i < dest_size; i++) { 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->Code = code; 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, - sizeof(ICMP_HEADER) + size); + sizeof(ICMP_HEADER) + size); Free(icmp); @@ -881,7 +881,7 @@ BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCH WriteBufBuf(b2, b); 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(b2); @@ -889,7 +889,7 @@ BUF *BuildICMPv6NeighborSoliciation(IPV6_ADDR *src_ip, IPV6_ADDR *target_ip, UCH 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_LINK_LAYER link; @@ -919,7 +919,7 @@ BUF *BuildICMPv6RouterSoliciation(IPV6_ADDR* src_ip, IPV6_ADDR* target_ip, UCHAR WriteBufBuf(b2, b); 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(b2); @@ -977,7 +977,7 @@ void BuildAndAddIPv6PacketOptionHeader(BUF *b, IPV6_OPTION_HEADER *opt, UCHAR ne // Build an IPv6 packet 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 ip_header; @@ -1058,21 +1058,21 @@ BUF *BuildIPv6PacketHeader(IPV6_HEADER_PACKET_INFO *info, UINT *bytes_before_pay if (info->HopHeader != NULL) { BuildAndAddIPv6PacketOptionHeader(b, info->HopHeader, - IPv6GetNextHeaderFromQueue(q), info->HopHeaderSize); + IPv6GetNextHeaderFromQueue(q), info->HopHeaderSize); } // End point option header if (info->EndPointHeader != NULL) { BuildAndAddIPv6PacketOptionHeader(b, info->EndPointHeader, - IPv6GetNextHeaderFromQueue(q), info->EndPointHeaderSize); + IPv6GetNextHeaderFromQueue(q), info->EndPointHeaderSize); } // Routing header if (info->RoutingHeader != NULL) { BuildAndAddIPv6PacketOptionHeader(b, info->RoutingHeader, - IPv6GetNextHeaderFromQueue(q), info->RoutingHeaderSize); + IPv6GetNextHeaderFromQueue(q), info->RoutingHeaderSize); } // Fragment header @@ -1362,22 +1362,22 @@ PKT *ClonePacket(PKT *p, bool copy_data) Copy(ret->L3.IPv6Header, p->L3.IPv6Header, sizeof(IPV6_HEADER)); ret->IPv6HeaderPacketInfo.IPv6Header = Clone(p->IPv6HeaderPacketInfo.IPv6Header, - sizeof(IPV6_HEADER)); + sizeof(IPV6_HEADER)); ret->IPv6HeaderPacketInfo.HopHeader = Clone(p->IPv6HeaderPacketInfo.HopHeader, - sizeof(IPV6_OPTION_HEADER)); + sizeof(IPV6_OPTION_HEADER)); ret->IPv6HeaderPacketInfo.EndPointHeader = Clone(p->IPv6HeaderPacketInfo.EndPointHeader, - sizeof(IPV6_OPTION_HEADER)); + sizeof(IPV6_OPTION_HEADER)); ret->IPv6HeaderPacketInfo.RoutingHeader = Clone(p->IPv6HeaderPacketInfo.RoutingHeader, - sizeof(IPV6_OPTION_HEADER)); + sizeof(IPV6_OPTION_HEADER)); ret->IPv6HeaderPacketInfo.FragmentHeader = Clone(p->IPv6HeaderPacketInfo.FragmentHeader, - sizeof(IPV6_FRAGMENT_HEADER)); + sizeof(IPV6_FRAGMENT_HEADER)); ret->IPv6HeaderPacketInfo.Payload = Clone(p->IPv6HeaderPacketInfo.Payload, - p->IPv6HeaderPacketInfo.PayloadSize); + p->IPv6HeaderPacketInfo.PayloadSize); break; } @@ -1397,10 +1397,10 @@ PKT *ClonePacket(PKT *p, bool copy_data) Copy(ret->L4.ICMPHeader, p->L4.ICMPHeader, sizeof(ICMP_HEADER)); ret->ICMPv6HeaderPacketInfo.Data = Clone(p->ICMPv6HeaderPacketInfo.Data, - p->ICMPv6HeaderPacketInfo.DataSize); + p->ICMPv6HeaderPacketInfo.DataSize); ret->ICMPv6HeaderPacketInfo.EchoData = Clone(p->ICMPv6HeaderPacketInfo.EchoData, - p->ICMPv6HeaderPacketInfo.EchoDataSize); + p->ICMPv6HeaderPacketInfo.EchoDataSize); switch (ret->ICMPv6HeaderPacketInfo.Type) { @@ -1410,31 +1410,31 @@ PKT *ClonePacket(PKT *p, bool copy_data) case ICMPV6_TYPE_ROUTER_SOLICIATION: ret->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader = - Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader, - sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)); + Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterSoliciationHeader, + sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)); break; case ICMPV6_TYPE_ROUTER_ADVERTISEMENT: ret->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader = - Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader, - sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)); + Clone(p->ICMPv6HeaderPacketInfo.Headers.RouterAdvertisementHeader, + sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)); break; case ICMPV6_TYPE_NEIGHBOR_SOLICIATION: ret->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader = - Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader, - sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)); + Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborSoliciationHeader, + sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)); break; case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: ret->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader = - Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader, - sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)); + Clone(p->ICMPv6HeaderPacketInfo.Headers.NeighborAdvertisementHeader, + sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)); break; } CloneICMPv6Options(&ret->ICMPv6HeaderPacketInfo.OptionList, - &p->ICMPv6HeaderPacketInfo.OptionList); + &p->ICMPv6HeaderPacketInfo.OptionList); break; case L4_TCP: @@ -1465,10 +1465,10 @@ PKT *ClonePacket(PKT *p, bool copy_data) ret->L7.IkeHeader = MallocFast(sizeof(IKE_HEADER)); Copy(ret->L7.IkeHeader, p->L7.IkeHeader, sizeof(IKE_HEADER)); break; - - case L7_DNS: - StrCpy(ret->DnsQueryHost, sizeof(ret->DnsQueryHost), p->DnsQueryHost); - break; + + case L7_DNS: + StrCpy(ret->DnsQueryHost, sizeof(ret->DnsQueryHost), p->DnsQueryHost); + break; } // Address data @@ -1491,7 +1491,7 @@ PKT *ClonePacket(PKT *p, bool copy_data) } // 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); } @@ -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); } -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); } -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; 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; 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) { @@ -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 && - (!((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) { @@ -1879,8 +1879,8 @@ HTTPLOG *ParseHttpAccessLog(PKT *pkt) // Check whether it starts with the HTTP-specific string if (CmpCaseIgnore(buf, "GET ", 4) != 0 && - CmpCaseIgnore(buf, "HEAD ", 5) != 0 && - CmpCaseIgnore(buf, "POST ", 5) != 0) + CmpCaseIgnore(buf, "HEAD ", 5) != 0 && + CmpCaseIgnore(buf, "POST ", 5) != 0) { 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; b1 = true; b2 = true; - for (i = 0;i < 6;i++) + for (i = 0; i < 6; i++) { 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 { // 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; LLC_HEADER *llc; @@ -2482,10 +2482,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size) } 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), - icmp_info.DataSize - sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)) == false) + icmp_info.DataSize - sizeof(ICMPV6_ROUTER_SOLICIATION_HEADER)) == false) { return false; } @@ -2500,10 +2500,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size) } 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), - icmp_info.DataSize - sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)) == false) + icmp_info.DataSize - sizeof(ICMPV6_ROUTER_ADVERTISEMENT_HEADER)) == false) { return false; } @@ -2518,10 +2518,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size) } 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), - icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)) == false) + icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER)) == false) { return false; } @@ -2536,10 +2536,10 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size) } 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), - icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)) == false) + icmp_info.DataSize - sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)) == 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 if (no_l3_l4_except_icmpv6) - { + { return true; } return ParseTCP(p, buf, size); @@ -2987,7 +2987,7 @@ bool ParseUDP(PKT *p, UCHAR *buf, UINT size) dst_port = Endian16(p->L4.UDPHeader->DstPort); if ((src_port == 67 && dst_port == 68) || - (src_port == 68 && dst_port == 67)) + (src_port == 68 && dst_port == 67)) { if (p->TypeL3 == L3_IPV4) { @@ -2997,13 +2997,13 @@ bool ParseUDP(PKT *p, UCHAR *buf, UINT size) return true; } } - - if (dst_port == 53) + + if (dst_port == 53) { - ParseDNS(p, buf, size); - return true; - } - + ParseDNS(p, buf, size); + return true; + } + 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; if (ike_header->InitiatorCookie != 0 && ike_header->ResponderCookie == 0 && - (ike_header->ExchangeType == IKE_EXCHANGE_TYPE_MAIN || - ike_header->ExchangeType == IKE_EXCHANGE_TYPE_AGGRESSIVE)) + (ike_header->ExchangeType == IKE_EXCHANGE_TYPE_MAIN || + ike_header->ExchangeType == IKE_EXCHANGE_TYPE_AGGRESSIVE)) { // the IKE connection request packet is found p->TypeL7 = L7_IKECONN; @@ -3303,7 +3303,7 @@ BUF *BuildDhcpOptionsBuf(LIST *o) } 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); UINT current_size = d->Size; @@ -3612,7 +3612,7 @@ void BuildClasslessRouteTableStr(char *str, UINT str_size, DHCP_CLASSLESS_ROUTE_ 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]; @@ -3684,7 +3684,7 @@ bool ParseClasslessRouteTableStr(DHCP_CLASSLESS_ROUTE_TABLE *d, char *str) { UINT i; - for (i = 0;i < t->NumTokens;i++) + for (i = 0; i < t->NumTokens; i++) { DHCP_CLASSLESS_ROUTE r; @@ -3784,7 +3784,7 @@ BUF *DhcpBuildClasslessRouteData(DHCP_CLASSLESS_ROUTE_TABLE *t) 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]; @@ -3883,7 +3883,7 @@ void DhcpParseClasslessRouteData(DHCP_CLASSLESS_ROUTE_TABLE *t, void *data, UINT Copy(&r.SubnetMask, &mask, sizeof(IP)); 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) { @@ -3919,7 +3919,7 @@ DHCP_OPTION *GetDhcpOption(LIST *o, UINT id) 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); if (opt->Id == id) @@ -3947,7 +3947,7 @@ DHCP_CLASSLESS_ROUTE *GetBestClasslessRoute(DHCP_CLASSLESS_ROUTE_TABLE *t, IP *i 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]; @@ -3977,7 +3977,7 @@ void FreeDhcpOptions(LIST *o) return; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { DHCP_OPTION *opt = LIST_DATA(o, i); Free(opt->Data); @@ -4096,10 +4096,10 @@ BUF *DhcpModifyIPv4(DHCP_MODIFY_OPTION *m, void *data, UINT size) udp->Checksum = 0; udp->Checksum = CalcChecksumForIPv4(p->L3.IPv4Header->SrcIP, - p->L3.IPv4Header->DstIP, - IP_PROTO_UDP, - udp, - p->PacketSize - (UINT)(((UCHAR *)udp) - ((UCHAR *)p->PacketData)), 0); + p->L3.IPv4Header->DstIP, + IP_PROTO_UDP, + udp, + p->PacketSize - (UINT)(((UCHAR *)udp) - ((UCHAR *)p->PacketData)), 0); } FreePacket(p); @@ -4183,7 +4183,7 @@ BUF *DhcpModify(DHCP_MODIFY_OPTION *m, void *data, UINT size) // Rebuilding the options list 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 *o2 = NULL; diff --git a/src/Mayaqua/TcpIp.h b/src/Mayaqua/TcpIp.h index 89ca3a95..85f55c67 100644 --- a/src/Mayaqua/TcpIp.h +++ b/src/Mayaqua/TcpIp.h @@ -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 *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* 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 *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); void FreePacket(PKT *p); void FreePacketWithData(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); 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, - UINT size); + UINT size); BUF *BuildIPv6PacketHeader(IPV6_HEADER_PACKET_INFO *info, UINT *bytes_before_payload); UCHAR IPv6GetNextHeaderFromQueue(QUEUE *q); 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 *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); bool VLanRemoveTag(void **packet_data, UINT *packet_size, UINT vlan_id, UINT vlan_tpid); From f2fee4d32c1898cfe0e315f50c3f29a6ac3af3fd Mon Sep 17 00:00:00 2001 From: Evengard Date: Tue, 12 May 2020 01:06:59 +0300 Subject: [PATCH 3/6] Preliminary implementation of IPv6CP and IPv6 for PPP (untested) --- src/Cedar/BridgeUnix.c | 158 +++---- src/Cedar/CedarType.h | 1 + src/Cedar/IPC.c | 243 ++++++---- src/Cedar/IPC.h | 27 +- src/Cedar/Proto_OpenVPN.c | 177 ++++---- src/Cedar/Proto_PPP.c | 289 +++++++++--- src/Cedar/Proto_PPP.h | 15 +- src/Cedar/Virtual.c | 915 ++++++++++++++++++++------------------ src/Mayaqua/Network.c | 1 + 9 files changed, 1087 insertions(+), 739 deletions(-) diff --git a/src/Cedar/BridgeUnix.c b/src/Cedar/BridgeUnix.c index 95410787..5fa21762 100644 --- a/src/Cedar/BridgeUnix.c +++ b/src/Cedar/BridgeUnix.c @@ -232,12 +232,12 @@ TOKEN_LIST *GetEthListSolaris() lifc.lifc_family = AF_INET; lifc.lifc_flags = 0; lifc.lifc_len = bufsize; - lifc.lifc_buf = (char*) buf; + lifc.lifc_buf = (char *) buf; if (ioctl(s, SIOCGLIFCONF, (char *)&lifc) >= 0) { for (i = 0; iNumTokens = LIST_NUM(o); t->Token = ZeroMalloc(sizeof(char *) * t->NumTokens); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { char *name = LIST_DATA(o, i); t->Token[i] = name; @@ -287,7 +287,7 @@ TOKEN_LIST *GetEthListLinux(bool enum_normal, bool enum_rawip) if (s != INVALID_SOCKET) { n = 0; - for (i = 0;;i++) + for (i = 0;; i++) { Zero(&ifr, sizeof(ifr)); ifr.ifr_ifindex = i; @@ -332,7 +332,7 @@ TOKEN_LIST *GetEthListLinux(bool enum_normal, bool enum_rawip) t->NumTokens = LIST_NUM(o) + (enum_rawip ? 1 : 0); t->Token = ZeroMalloc(sizeof(char *) * t->NumTokens); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { char *name = LIST_DATA(o, i); t->Token[i] = name; @@ -372,9 +372,9 @@ TOKEN_LIST *GetEthListPcap() if(p != NULL) { int datalink = pcap_datalink(p); - // Debug("type:%s\n",pcap_datalink_val_to_name(datalink)); + // Debug("type:%s\n",pcap_datalink_val_to_name(datalink)); pcap_close(p); - if(datalink == DLT_EN10MB){ + if(datalink == DLT_EN10MB) { // Enumerate only Ethernet type device Add(o, CopyStr(dev->name)); } @@ -388,7 +388,7 @@ TOKEN_LIST *GetEthListPcap() t = ZeroMalloc(sizeof(TOKEN_LIST)); t->NumTokens = LIST_NUM(o); t->Token = ZeroMalloc(sizeof(char *) * t->NumTokens); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { t->Token[i] = LIST_DATA(o, i); } @@ -415,7 +415,7 @@ TOKEN_LIST *GetEthListBpf() struct ifaddrs *ifadr = ifadrs; while(ifadr) { - sockadr = (struct sockaddr_dl*)ifadr->ifa_addr; + sockadr = (struct sockaddr_dl *)ifadr->ifa_addr; if(sockadr->sdl_family == AF_LINK && sockadr->sdl_type == IFT_ETHER) { // Is this Ethernet device? @@ -434,7 +434,7 @@ TOKEN_LIST *GetEthListBpf() t = ZeroMalloc(sizeof(TOKEN_LIST)); t->NumTokens = LIST_NUM(o); t->Token = ZeroMalloc(sizeof(char *) * t->NumTokens); - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { t->Token[i] = LIST_DATA(o, i); } @@ -1070,7 +1070,7 @@ bool ParseUnixEthDeviceName(char *dst_devname, UINT dst_devname_size, char *src_ #if defined(BRIDGE_BPF) || defined(BRIDGE_PCAP) // Initialize captured packet data structure -struct CAPTUREBLOCK *NewCaptureBlock(UCHAR *data, UINT size){ +struct CAPTUREBLOCK *NewCaptureBlock(UCHAR *data, UINT size) { struct CAPTUREBLOCK *block = Malloc(sizeof(struct CAPTUREBLOCK)); block->Buf = data; block->Size = size; @@ -1078,7 +1078,7 @@ struct CAPTUREBLOCK *NewCaptureBlock(UCHAR *data, UINT size){ } // Free captured packet data structure -void FreeCaptureBlock(struct CAPTUREBLOCK *block){ +void FreeCaptureBlock(struct CAPTUREBLOCK *block) { Free(block); } #endif // BRIDGE_BPF || BRIDGE_PCAP @@ -1087,7 +1087,7 @@ void FreeCaptureBlock(struct CAPTUREBLOCK *block){ // Callback function to receive arriving packet (Pcap) void PcapHandler(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) { - ETH *e = (ETH*) user; + ETH *e = (ETH *) user; struct CAPTUREBLOCK *block; UCHAR *data; @@ -1096,7 +1096,7 @@ void PcapHandler(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) block = NewCaptureBlock(data, h->caplen); LockQueue(e->Queue); // Discard arriving packet when queue filled - if(e->QueueSize < BRIDGE_MAX_QUEUE_SIZE){ + if(e->QueueSize < BRIDGE_MAX_QUEUE_SIZE) { InsertQueue(e->Queue, block); e->QueueSize += h->caplen; } @@ -1108,7 +1108,7 @@ void PcapHandler(u_char *user, const struct pcap_pkthdr *h, const u_char *bytes) // Relay thread for captured packet (Pcap) void PcapThread(THREAD *thread, void *param) { - ETH *e = (ETH*)param; + ETH *e = (ETH *)param; pcap_t *p = e->Pcap; int ret; @@ -1116,8 +1116,8 @@ void PcapThread(THREAD *thread, void *param) NoticeThreadInit(thread); // Return -1:Error -2:Terminated externally - ret = pcap_loop(p, -1, PcapHandler, (u_char*) e); - if(ret == -1){ + ret = pcap_loop(p, -1, PcapHandler, (u_char *) e); + if(ret == -1) { e->Socket = INVALID_SOCKET; pcap_perror(p, "capture"); } @@ -1181,7 +1181,7 @@ ETH *OpenEthPcap(char *name, bool local, bool tapmode, char *tapaddr) // Relay thread for captured packet (BPF) void BpfThread(THREAD *thread, void *param) { - ETH *e = (ETH*)param; + ETH *e = (ETH *)param; int fd = e->Socket; int len; int rest; // Rest size in buffer @@ -1196,14 +1196,14 @@ void BpfThread(THREAD *thread, void *param) // Notify initialize completed NoticeThreadInit(thread); - while(1){ + while(1) { // Determining to exit loop - if(e->Socket == INVALID_SOCKET){ + if(e->Socket == INVALID_SOCKET) { break; } rest = read(fd, buf, e->BufSize); - if(rest < 0 && errno != EAGAIN){ + if(rest < 0 && errno != EAGAIN) { // Error close(fd); e->Socket = INVALID_SOCKET; @@ -1213,12 +1213,12 @@ void BpfThread(THREAD *thread, void *param) } next = buf; LockQueue(e->Queue); - while(rest>0){ + while(rest>0) { // Cut out a packet - hdr = (struct bpf_hdr*)next; + hdr = (struct bpf_hdr *)next; // Discard arriving packet when queue filled - if(e->QueueSize < BRIDGE_MAX_QUEUE_SIZE){ + if(e->QueueSize < BRIDGE_MAX_QUEUE_SIZE) { data = Malloc(hdr->bh_caplen); Copy(data, next+(hdr->bh_hdrlen), hdr->bh_caplen); block = NewCaptureBlock(data, hdr->bh_caplen); @@ -1253,31 +1253,31 @@ ETH *OpenEthBpf(char *name, bool local, bool tapmode, char *tapaddr) struct timeval to; // Find unused bpf device and open it - do{ + do { Format(devname, sizeof(devname), "/dev/bpf%d", n++); fd = open (devname, O_RDWR); - if(fd<0){ + if(fd<0) { perror("open"); } - }while(fd < 0 && errno == EBUSY); + } while(fd < 0 && errno == EBUSY); // No free bpf device was found - if(fd < 0){ + if(fd < 0) { Debug("BPF: No minor number are free.\n"); return NULL; } // Enlarge buffer size n = 524288; // Somehow(In libpcap, this size is 32768) - while(true){ + while(true) { // Specify buffer size ioctl(fd, BIOCSBLEN, &n); // Bind to the network device StrCpy(ifr.ifr_name, IFNAMSIZ, name); ret = ioctl(fd, BIOCSETIF, &ifr); - if(ret < 0){ - if(ret == ENOBUFS && n>1500){ + if(ret < 0) { + if(ret == ENOBUFS && n>1500) { // Inappropriate buffer size // Retry with half buffer size // If buffer size is under 1500 bytes, something goes wrong @@ -1287,15 +1287,15 @@ ETH *OpenEthBpf(char *name, bool local, bool tapmode, char *tapaddr) Debug("bpf: binding network failed.\n"); close(fd); return NULL; - }else{ + } else { break; } } bufsize = n; // Set to promiscuous mode - if(local == false){ - if (ioctl(fd, BIOCPROMISC, NULL) < 0){ + if(local == false) { + if (ioctl(fd, BIOCPROMISC, NULL) < 0) { printf("bpf: promisc mode failed.\n"); close(fd); return NULL; @@ -1305,7 +1305,7 @@ ETH *OpenEthBpf(char *name, bool local, bool tapmode, char *tapaddr) // Set to immediate mode (Return immediately when packet arrives) n = 1; - if (ioctl(fd, BIOCIMMEDIATE, &n) < 0){ + if (ioctl(fd, BIOCIMMEDIATE, &n) < 0) { Debug("BPF: non-block mode failed.\n"); close(fd); return NULL; @@ -1313,7 +1313,7 @@ ETH *OpenEthBpf(char *name, bool local, bool tapmode, char *tapaddr) // Set receiving self sending packet n = 1; - if (ioctl(fd, BIOCGSEESENT, &n) < 0){ + if (ioctl(fd, BIOCGSEESENT, &n) < 0) { Debug("BPF: see sent mode failed.\n"); close(fd); return NULL; @@ -1321,7 +1321,7 @@ ETH *OpenEthBpf(char *name, bool local, bool tapmode, char *tapaddr) // Header complete mode (Generate whole header of sending packet) n = 1; - if (ioctl(fd, BIOCSHDRCMPLT, &n) < 0){ + if (ioctl(fd, BIOCSHDRCMPLT, &n) < 0) { Debug("BPF: Header complete mode failed.\n"); close(fd); return NULL; @@ -1330,7 +1330,7 @@ ETH *OpenEthBpf(char *name, bool local, bool tapmode, char *tapaddr) // Set timeout delay to 1 second to.tv_sec = 1; to.tv_usec = 0; - if (ioctl(fd, BIOCSRTIMEOUT, &to) < 0){ + if (ioctl(fd, BIOCSRTIMEOUT, &to) < 0) { Debug("BPF: Read timeout setting failed.\n"); close(fd); return NULL; @@ -1401,16 +1401,16 @@ ETH *OpenEthBSD(char *name, bool local, bool tapmode, char *tapaddr) return e; #else // NO_VLAN - return NULL: +return NULL: #endif // NO_VLAN } #if defined(BRIDGE_BPF) - return OpenEthBpf(name, local, tapmode, tapaddr); + return OpenEthBpf(name, local, tapmode, tapaddr); #elif defined(BRIDGE_PCAP) - return OpenEthPcap(name, local, tapmode, tapaddr); + return OpenEthPcap(name, local, tapmode, tapaddr); #else - return NULL; + return NULL; #endif } #endif // UNIX_BSD @@ -1471,7 +1471,7 @@ void CloseEth(ETH *e) WaitThread(e->CaptureThread, INFINITE); ReleaseThread(e->CaptureThread); pcap_close(e->Pcap); - while (block = GetNext(e->Queue)){ + while (block = GetNext(e->Queue)) { Free(block->Buf); FreeCaptureBlock(block); } @@ -1488,7 +1488,7 @@ void CloseEth(ETH *e) WaitThread(e->CaptureThread, INFINITE); ReleaseThread(e->CaptureThread); e->Socket = fd; // restore to close after - while (block = GetNext(e->Queue)){ + while (block = GetNext(e->Queue)) { Free(block->Buf); FreeCaptureBlock(block); } @@ -1660,8 +1660,8 @@ UINT EthGetPacketLinux(ETH *e, void **data) USHORT vlan_id = 0; if (cmsg->cmsg_len < CMSG_LEN(sizeof(struct my_tpacket_auxdata)) || - cmsg->cmsg_level != SOL_PACKET || - cmsg->cmsg_type != MY_PACKET_AUXDATA) + cmsg->cmsg_level != SOL_PACKET || + cmsg->cmsg_type != MY_PACKET_AUXDATA) { continue; } @@ -1772,14 +1772,14 @@ UINT EthGetPacketPcap(ETH *e, void **data) LockQueue(e->Queue); block = GetNext(e->Queue); - if(block != NULL){ + if(block != NULL) { e->QueueSize -= block->Size; } UnlockQueue(e->Queue); - if(block == NULL){ + if(block == NULL) { *data = NULL; - if(e->Socket == INVALID_SOCKET){ + if(e->Socket == INVALID_SOCKET) { return INFINITE; } return 0; @@ -1802,14 +1802,14 @@ UINT EthGetPacketBpf(ETH *e, void **data) LockQueue(e->Queue); block = GetNext(e->Queue); - if(block != NULL){ + if(block != NULL) { e->QueueSize -= block->Size; } UnlockQueue(e->Queue); - if(block == NULL){ + if(block == NULL) { *data = NULL; - if(e->Socket == INVALID_SOCKET){ + if(e->Socket == INVALID_SOCKET) { return INFINITE; } return 0; @@ -1826,11 +1826,11 @@ UINT EthGetPacketBpf(ETH *e, void **data) { struct bpf_hdr *hdr; - if(e->Rest<=0){ + if(e->Rest<=0) { e->Rest = read(e->Socket, e->Buffer, e->BufSize); - if(e->Rest < 0){ + if(e->Rest < 0) { *data = NULL; - if(errno != EAGAIN){ + if(errno != EAGAIN) { // Error return INFINITE; } @@ -1840,7 +1840,7 @@ UINT EthGetPacketBpf(ETH *e, void **data) e->Next = e->Buffer; } // Cut out a packet - hdr = (struct bpf_hdr*)e->Next; + hdr = (struct bpf_hdr *)e->Next; *data = Malloc(hdr->bh_caplen); Copy(*data, e->Next+(hdr->bh_hdrlen), hdr->bh_caplen); @@ -1864,7 +1864,7 @@ void EthPutPackets(ETH *e, UINT num, void **datas, UINT *sizes) return; } - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { EthPutPacket(e, datas[i], sizes[i]); } @@ -1910,7 +1910,7 @@ void EthPutPacket(ETH *e, void *data, UINT size) // Send to device #ifdef BRIDGE_PCAP ret = pcap_inject(e->Pcap, data, size); - if( ret == -1 ){ + if( ret == -1 ) { #ifdef _DEBUG pcap_perror(e->Pcap, "inject"); #endif // _DEBUG @@ -2162,7 +2162,7 @@ LABEL_RETRY: UINTToIP(&original_dest_ip, ip->DstIP); if (IsZeroIP(&e->MyPhysicalIPForce) == false && CmpIpAddr(&e->MyPhysicalIPForce, &original_dest_ip) == 0 || - (IsIPMyHost(&original_dest_ip) && IsLocalHostIP(&original_dest_ip) == false && IsHostIPAddress4(&original_dest_ip))) + (IsIPMyHost(&original_dest_ip) && IsLocalHostIP(&original_dest_ip) == false && IsHostIPAddress4(&original_dest_ip))) { if (IsZeroIP(&e->MyPhysicalIPForce) && CmpIpAddr(&e->MyPhysicalIP, &original_dest_ip) != 0) { @@ -2183,14 +2183,14 @@ LABEL_RETRY: if (p->TypeL4 == L4_TCP) { TCP_HEADER *tcp = p->L4.TCPHeader; -/* - if (Endian16(tcp->SrcPort) == 80) - { - IP a, b; - UINTToIP(&a, ip->SrcIP); - UINTToIP(&b, ip->DstIP); - Debug("%r %r %u %u\n", &a, &b, Endian16(tcp->SrcPort), Endian16(tcp->DstPort)); - }*/ + /* + if (Endian16(tcp->SrcPort) == 80) + { + IP a, b; + UINTToIP(&a, ip->SrcIP); + UINTToIP(&b, ip->DstIP); + Debug("%r %r %u %u\n", &a, &b, Endian16(tcp->SrcPort), Endian16(tcp->DstPort)); + }*/ ok = true; } @@ -2226,7 +2226,7 @@ LABEL_RETRY: if (inner_icmp_size >= (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO))) { ICMP_HEADER *inner_icmp = (ICMP_HEADER *)(((UCHAR *)data) + - sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + orig_ipv4_header_size); + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + orig_ipv4_header_size); if (inner_icmp->Type == ICMP_TYPE_ECHO_REQUEST) { @@ -2328,8 +2328,8 @@ bool EthProcessIpPacketInnerIpRaw(ETH *e, PKT *p) ARPV4_HEADER *arp = p->L3.ARPv4Header; if (Endian16(arp->HardwareType) == ARP_HARDWARE_TYPE_ETHERNET && - Endian16(arp->ProtocolType) == MAC_PROTO_IPV4 && - arp->HardwareSize == 6 && arp->ProtocolType == 4) + Endian16(arp->ProtocolType) == MAC_PROTO_IPV4 && + arp->HardwareSize == 6 && arp->ProtocolType == 4) { if (IPToUINT(&e->MyIP) == arp->TargetIP) { @@ -2460,8 +2460,8 @@ bool EthProcessIpPacketInnerIpRaw(ETH *e, PKT *p) UINTToIP(&ips, ip); IPToStr(client_ip, sizeof(client_ip), &ips); Debug("IP_RAW: DHCP %s : %s given %s\n", - ret.Opcode == DHCP_OFFER ? "DHCP_OFFER" : "DHCP_ACK", - client_mac, client_ip); + ret.Opcode == DHCP_OFFER ? "DHCP_OFFER" : "DHCP_ACK", + client_mac, client_ip); } // Build a DHCP option @@ -2538,7 +2538,7 @@ bool EthProcessIpPacketInnerIpRaw(ETH *e, PKT *p) udp->DstPort = Endian16(NAT_DHCP_CLIENT_PORT); udp->PacketLength = Endian16(sizeof(UDP_HEADER) + dhcp_packet_size); udp->Checksum = CalcChecksumForIPv4(ipv4->SrcIP, ipv4->DstIP, IP_PROTO_UDP, - dhcp, dhcp_packet_size, 0); + dhcp, dhcp_packet_size, 0); if (udp->Checksum == 0) { udp->Checksum = 0xffff; @@ -2589,14 +2589,14 @@ void EthPutPacketLinuxIpRaw(ETH *e, void *data, UINT size) if (p->BroadcastPacket || Cmp(p->MacAddressDest, e->RawIpMyMacAddr, 6) == 0) { - if (IsValidUnicastMacAddress(p->MacAddressSrc)) + if (IsMacUnicast(p->MacAddressSrc)) { Copy(e->RawIpYourMacAddr, p->MacAddressSrc, 6); } } - if (IsZero(e->RawIpYourMacAddr, 6) || IsValidUnicastMacAddress(p->MacAddressSrc) == false || - (p->BroadcastPacket == false && Cmp(p->MacAddressDest, e->RawIpMyMacAddr, 6) != 0)) + if (IsZero(e->RawIpYourMacAddr, 6) || IsMacUnicast(p->MacAddressSrc) == false || + (p->BroadcastPacket == false && Cmp(p->MacAddressDest, e->RawIpMyMacAddr, 6) != 0)) { Free(data); FreePacket(p); @@ -2641,7 +2641,7 @@ void EthPutPacketLinuxIpRaw(ETH *e, void *data, UINT size) } if (s != NULL && p->L3.IPv4Header->DstIP != 0xffffffff && p->BroadcastPacket == false && - p->L3.IPv4Header->SrcIP == IPToUINT(&e->YourIP)) + p->L3.IPv4Header->SrcIP == IPToUINT(&e->YourIP)) { UCHAR *send_data = p->IPv4PayloadData; UCHAR *head = p->PacketData; @@ -2661,8 +2661,8 @@ void EthPutPacketLinuxIpRaw(ETH *e, void *data, UINT size) { p->L4.TCPHeader->Checksum = 0; p->L4.TCPHeader->Checksum = CalcChecksumForIPv4(IPToUINT(&e->MyPhysicalIP), - p->L3.IPv4Header->DstIP, IP_PROTO_TCP, - p->L4.TCPHeader, p->IPv4PayloadSize, 0); + p->L3.IPv4Header->DstIP, IP_PROTO_TCP, + p->L4.TCPHeader, p->IPv4PayloadSize, 0); } UINTToIP(&dest, p->L3.IPv4Header->DstIP); diff --git a/src/Cedar/CedarType.h b/src/Cedar/CedarType.h index 61f8c5b8..620d0291 100644 --- a/src/Cedar/CedarType.h +++ b/src/Cedar/CedarType.h @@ -583,6 +583,7 @@ typedef struct IPC_DHCP_RELEASE_QUEUE IPC_DHCP_RELEASE_QUEUE; typedef struct IPC_MSCHAP_V2_AUTHINFO IPC_MSCHAP_V2_AUTHINFO; typedef struct IPC_SESSION_SHARED_BUFFER_DATA IPC_SESSION_SHARED_BUFFER_DATA; typedef struct IPC_IPV6_ROUTER_ADVERTISEMENT IPC_IPV6_ROUTER_ADVERTISEMENT; +typedef struct IPC_DHCPV4_AWAIT IPC_DHCPV4_AWAIT; // ============================================================== diff --git a/src/Cedar/IPC.c b/src/Cedar/IPC.c index ed80f64f..899238b5 100644 --- a/src/Cedar/IPC.c +++ b/src/Cedar/IPC.c @@ -147,7 +147,7 @@ void IPCAsyncThreadProc(THREAD *thread, void *param) // Save the options list Copy(&a->L3ClientAddressOption, &cao, sizeof(DHCP_OPTION_LIST)); - a->L3DhcpRenewInterval = t * 1000; + a->L3DhcpRenewInterval = (UINT64)t * (UINT64)1000; // Set the obtained IP address parameters to the IPC virtual host UINTToIP(&ip, cao.ClientAddress); @@ -488,6 +488,10 @@ IPC *NewIPC(CEDAR *cedar, char *client_name, char *postfix, char *hubname, char // Create an IPv4 reception queue ipc->IPv4ReceivedQueue = NewQueue(); + ipc->IPv4State = IPC_PROTO_STATUS_CLOSED; + + ipc->DHCPv4Awaiter.IsAwaiting = false; + ipc->DHCPv4Awaiter.DhcpData = NULL; IPCIPv6Init(ipc); @@ -530,6 +534,10 @@ IPC *NewIPCBySock(CEDAR *cedar, SOCK *s, void *mac_address) // Create an IPv4 reception queue ipc->IPv4ReceivedQueue = NewQueue(); + ipc->IPv4State = IPC_PROTO_STATUS_CLOSED; + + ipc->DHCPv4Awaiter.IsAwaiting = false; + ipc->DHCPv4Awaiter.DhcpData = NULL; ipc->FlushList = NewTubeFlushList(); @@ -614,6 +622,8 @@ void FreeIPC(IPC *ipc) ReleaseSharedBuffer(ipc->IpcSessionSharedBuffer); + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + IPCIPv6Free(ipc); Free(ipc); @@ -871,6 +881,9 @@ DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION // Time-out inspection if ((expecting_code != 0) && (now >= giveup_time)) { + ipc->DHCPv4Awaiter.IsAwaiting = false; + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = NULL; return NULL; } @@ -880,6 +893,9 @@ DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION dhcp_packet = IPCBuildDhcpRequest(ipc, dest_ip, tran_id, opt); if (dhcp_packet == NULL) { + ipc->DHCPv4Awaiter.IsAwaiting = false; + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = NULL; return NULL; } @@ -889,6 +905,9 @@ DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION if (expecting_code == 0) { + ipc->DHCPv4Awaiter.IsAwaiting = false; + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = NULL; return NULL; } @@ -898,48 +917,28 @@ DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION } // Happy processing + ipc->DHCPv4Awaiter.IsAwaiting = true; + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = NULL; + ipc->DHCPv4Awaiter.TransCode = tran_id; + ipc->DHCPv4Awaiter.OpCode = expecting_code; IPCProcessL3Events(ipc); - while (true) + if (ipc->DHCPv4Awaiter.DhcpData != NULL) { - // Receive a packet - BLOCK *b = IPCRecvIPv4(ipc); - PKT *pkt; - DHCPV4_DATA *dhcp; - - if (b == NULL) - { - break; - } - - // Parse the packet - pkt = ParsePacketIPv4WithDummyMacHeader(b->Buf, b->Size); - - dhcp = ParseDHCPv4Data(pkt); - - if (dhcp != NULL) - { - if (Endian32(dhcp->Header->TransactionId) == tran_id && dhcp->OpCode == expecting_code) - { - // Expected operation code and transaction ID are returned - FreePacketWithData(pkt); - FreeBlock(b); - - return dhcp; - } - - FreeDHCPv4Data(dhcp); - } - - FreePacketWithData(pkt); - - FreeBlock(b); + DHCPV4_DATA *dhcp = ipc->DHCPv4Awaiter.DhcpData; + ipc->DHCPv4Awaiter.IsAwaiting = false; + ipc->DHCPv4Awaiter.DhcpData = NULL; + return dhcp; } if (IsTubeConnected(ipc->Sock->RecvTube) == false || IsTubeConnected(ipc->Sock->SendTube) == false || (discon_poll_tube != NULL && IsTubeConnected(discon_poll_tube) == false)) { // Session is disconnected + ipc->DHCPv4Awaiter.IsAwaiting = false; + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = NULL; return NULL; } @@ -947,6 +946,9 @@ DHCPV4_DATA *IPCSendDhcpRequest(IPC *ipc, IP *dest_ip, UINT tran_id, DHCP_OPTION WaitForTubes(tubes, num_tubes, GetNextIntervalForInterrupt(ipc->Interrupt)); } + ipc->DHCPv4Awaiter.IsAwaiting = false; + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = NULL; return NULL; } @@ -1301,6 +1303,16 @@ void IPCProcessL3Events(IPC *ipc) { IPCProcessL3EventsEx(ipc, 0); } +void IPCProcessL3EventsIPv4Only(IPC *ipc) +{ + UINT previousStatus4 = IPC_PROTO_GET_STATUS(ipc, IPv4State); + UINT previousStatus6 = IPC_PROTO_GET_STATUS(ipc, IPv6State); + IPC_PROTO_SET_STATUS(ipc, IPv4State, IPC_PROTO_STATUS_OPENED); + IPC_PROTO_SET_STATUS(ipc, IPv6State, IPC_PROTO_STATUS_CLOSED); + IPCProcessL3Events(ipc); + IPC_PROTO_SET_STATUS(ipc, IPv4State, previousStatus4); + IPC_PROTO_SET_STATUS(ipc, IPv6State, previousStatus6); +} void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) { // Validate arguments @@ -1340,6 +1352,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) // If the source MAC address is itselves or invalid address, ignore the packet if (Cmp(src_mac, ipc->MacAddress, 6) != 0 && !IsMacUnicast(src_mac)) { + Debug("Received packed for L3 parsing\n"); if (protocol == MAC_PROTO_ARPV4) { // ARP receiving process @@ -1347,6 +1360,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) } else if (protocol == MAC_PROTO_IPV4) { + Debug("MAC_PROTO_IPV4\n"); // IPv4 receiving process if (b->Size >= (14 + 20)) { @@ -1390,10 +1404,43 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) if (ok) { + // Parse DHCP packets + bool packetConsumed = false; + if (ipc->DHCPv4Awaiter.IsAwaiting) + { + PKT *pkt; + DHCPV4_DATA *dhcp; + + Debug("Parsing for DHCP awaiter\n"); + pkt = ParsePacketIPv4WithDummyMacHeader(data, size); + dhcp = ParseDHCPv4Data(pkt); + + if (dhcp != NULL) + { + if (Endian32(dhcp->Header->TransactionId) == ipc->DHCPv4Awaiter.TransCode && + dhcp->OpCode == ipc->DHCPv4Awaiter.OpCode) + { + FreeDHCPv4Data(ipc->DHCPv4Awaiter.DhcpData); + ipc->DHCPv4Awaiter.DhcpData = dhcp; + packetConsumed = true; + } + else + { + FreeDHCPv4Data(dhcp); + } + } + + FreePacket(pkt); + } + IPCAssociateOnArpTable(ipc, &ip_src, src_mac); - // Place in the reception queue - InsertQueue(ipc->IPv4ReceivedQueue, NewBlock(data, size, 0)); + if (ipc->IPv4State == IPC_PROTO_STATUS_OPENED && !packetConsumed) + { + // Place in the reception queue + InsertQueue(ipc->IPv4ReceivedQueue, NewBlock(data, size, 0)); + } + } else { @@ -1409,8 +1456,9 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) { IP ip_src, ip_dst; bool ndtProcessed = false; + UINT size = p->L3.IPv6Header->PayloadLength + sizeof(IPV6_HEADER); - UCHAR *data = Clone(p->L3.IPv6Header, p->L3.IPv6Header->PayloadLength + sizeof(IPV6_HEADER)); + UCHAR *data = Clone(p->L3.IPv6Header, size); IPv6AddrToIP(&ip_src, &p->IPv6HeaderPacketInfo.IPv6Header->SrcAddress); IPv6AddrToIP(&ip_dst, &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress); @@ -1426,7 +1474,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) // We save the router advertisement data for later use IPCIPv6AddRouterPrefix(ipc, &p->ICMPv6HeaderPacketInfo.OptionList, src_mac, &ip_src); IPCIPv6AssociateOnNDTEx(ipc, &ip_src, src_mac, true); - IPCIPv6AssociateOnNDTEx(ipc, &ip_src, &p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer, true); + IPCIPv6AssociateOnNDTEx(ipc, &ip_src, &p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer->Address, true); break; case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: // We save the neighbor advertisements into NDT @@ -1445,7 +1493,10 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) } /// TODO: should we or not filter Neighbor Advertisements and/or Neighbor Solicitations? - InsertQueue(ipc->IPv6ReceivedQueue, data); + if (ipc->IPv6State == IPC_PROTO_STATUS_OPENED) + { + InsertQueue(ipc->IPv6ReceivedQueue, NewBlock(data, size, 0)); + } FreePacket(p); } @@ -1948,6 +1999,8 @@ void IPCIPv6Init(IPC *ipc) ipc->IPv6ClientEUI = 0; ipc->IPv6ServerEUI = 0; + + ipc->IPv6State = IPC_PROTO_STATUS_CLOSED; } void IPCIPv6Free(IPC *ipc) { @@ -2113,14 +2166,31 @@ void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now) } } -bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, IP *addr) +// Scan the hub IP Table to try to find the EUI-based link-local address +bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, UINT64 eui) { HUB t, *h; - IP_TABLE_ENTRY t, *e; + IP_TABLE_ENTRY i, *e; t.Name = ipc->HubName; + + // Construct link local from eui + ZeroIP6(&i.Ip); + i.Ip.ipv6_addr[0] = 0xFE; + i.Ip.ipv6_addr[1] = 0x80; + WRITE_UINT64(&i.Ip.ipv6_addr[8], &eui); + h = Search(ipc->Cedar->HubList, &t); - //h->IpTable + if (h != NULL) + { + e = Search(h->IpTable, &i); + if (e != NULL) + { + return true; + } + } + + return false; } // RA @@ -2175,45 +2245,66 @@ bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVER } // Send router solicitation and then eventually populate the info from Router Advertisements -void IPCIPv6SendRouterSolicitation(IPC *ipc) +UINT64 IPCIPv6GetServerEui(IPC *ipc) { - IP senderIP; - IP destIP; - UCHAR destMacAddress[6]; - IPV6_ADDR linkLocal; - BUF *packet; - Zero(&linkLocal, sizeof(IPV6_ADDR)); - - // Generate link local from client's EUI - linkLocal.Value[0] = 0xFE; - linkLocal.Value[1] = 0x80; - WRITE_UINT64(&linkLocal.Value[8], &ipc->IPv6ClientEUI); - - GetAllRouterMulticastAddress6(&destIP); - - // Generate the MAC address from the multicast address - destMacAddress[0] = 0x33; - destMacAddress[1] = 0x33; - WRITE_UINT(&destMacAddress[2], &destIP.ipv6_addr[12]); - - packet = BuildICMPv6RouterSoliciation(senderIP.ipv6_addr, destIP.ipv6_addr, ipc->MacAddress, 0); - - while (LIST_NUM(ipc->IPv6RouterAdvs) == 0) + // It is already configured, nothing to do here + if (ipc->IPv6ServerEUI != 0) { - UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); - UINT64 timeout_retry = Tick() + (UINT64)IPC_IPV6_RA_INTERVAL; - IPCIPv6SendWithDestMacAddr(ipc, packet->Buf, packet->Size, destMacAddress); + return ipc->IPv6ServerEUI; + } - AddInterrupt(ipc->Interrupt, timeout_retry); + // If we don't have a valid client EUI, we can't generate a correct link local + if (ipc->IPv6ClientEUI == 0) + { + return ipc->IPv6ServerEUI; + } - if (Tick64() >= giveup_time) + if (LIST_NUM(ipc->IPv6RouterAdvs) == 0) + { + IP senderIP; + IPV6_ADDR senderV6; + IP destIP; + IPV6_ADDR destV6; + UCHAR destMacAddress[6]; + IPV6_ADDR linkLocal; + BUF *packet; + + Zero(&linkLocal, sizeof(IPV6_ADDR)); + + // Generate link local from client's EUI + linkLocal.Value[0] = 0xFE; + linkLocal.Value[1] = 0x80; + WRITE_UINT64(&linkLocal.Value[8], &ipc->IPv6ClientEUI); + + GetAllRouterMulticastAddress6(&destIP); + + // Generate the MAC address from the multicast address + destMacAddress[0] = 0x33; + destMacAddress[1] = 0x33; + WRITE_UINT(&destMacAddress[2], &destIP.ipv6_addr[12]); + + IPToIPv6Addr(&senderV6, &senderIP); + IPToIPv6Addr(&destV6, &destIP); + + packet = BuildICMPv6RouterSoliciation(&senderV6, &destV6, ipc->MacAddress, 0); + + while (LIST_NUM(ipc->IPv6RouterAdvs) == 0) { - // We failed to receive any router advertisements - break; - } + UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); + UINT64 timeout_retry = Tick() + (UINT64)IPC_IPV6_RA_INTERVAL; + IPCIPv6SendWithDestMacAddr(ipc, packet->Buf, packet->Size, destMacAddress); - // The processing should populate the received RAs by itself - IPCProcessL3Events(ipc); + AddInterrupt(ipc->Interrupt, timeout_retry); + + if (Tick64() >= giveup_time) + { + // We failed to receive any router advertisements + break; + } + + // The processing should populate the received RAs by itself + IPCProcessL3Events(ipc); + } } // Populating the IPv6 Server EUI for IPV6CP @@ -2222,6 +2313,8 @@ void IPCIPv6SendRouterSolicitation(IPC *ipc) IPC_IPV6_ROUTER_ADVERTISEMENT *ra = LIST_DATA(ipc->IPv6RouterAdvs, 0); ipc->IPv6ServerEUI = READ_UINT64(&ra->RouterAddress.ipv6_addr[8]); } + + return ipc->IPv6ServerEUI; } // Data flow diff --git a/src/Cedar/IPC.h b/src/Cedar/IPC.h index 02ad2e72..3160f1d1 100644 --- a/src/Cedar/IPC.h +++ b/src/Cedar/IPC.h @@ -30,6 +30,16 @@ #define IPC_IPV6_RA_INTERVAL (4 * 1000) // as per RTR_SOLICITATION_INTERVAL constant of RFC4861 #define IPC_IPV6_RA_MAX_RETRIES 3 // as per MAX_RTR_SOLICITATIONS constant of RFC4861 +// Protocol status +#define IPC_PROTO_STATUS_CLOSED 0x0 +#define IPC_PROTO_STATUS_CONFIG 0x1 +#define IPC_PROTO_STATUS_CONFIG_WAIT 0x2 +#define IPC_PROTO_STATUS_OPENED 0x10 +#define IPC_PROTO_STATUS_REJECTED 0x100 + +#define IPC_PROTO_SET_STATUS(ipc, proto, value) ((ipc) != NULL ? ((ipc->proto) = (value)) : 0) +#define IPC_PROTO_GET_STATUS(ipc, proto) ((ipc) != NULL ? (ipc->proto) : IPC_PROTO_STATUS_REJECTED) + // ARP table entry struct IPC_ARP { @@ -78,6 +88,15 @@ struct IPC_PARAM UINT Layer; }; +// DHCPv4 response awaiter +struct IPC_DHCPV4_AWAIT +{ + bool IsAwaiting; + DHCPV4_DATA *DhcpData; + UINT TransCode; + UINT OpCode; +}; + // IPC_ASYNC object struct IPC_ASYNC { @@ -117,6 +136,8 @@ struct IPC UCHAR Padding[2]; LIST *ArpTable; // ARP table QUEUE *IPv4ReceivedQueue; // IPv4 reception queue + UINT IPv4State; + IPC_DHCPV4_AWAIT DHCPv4Awaiter; TUBE_FLUSH_LIST *FlushList; // Tube Flush List UCHAR MsChapV2_ServerResponse[20]; // Server response DHCP_CLASSLESS_ROUTE_TABLE ClasslessRoute; // Classless routing table @@ -126,6 +147,7 @@ struct IPC // IPv6 stuff QUEUE *IPv6ReceivedQueue; // IPv6 reception queue + UINT IPv6State; LIST *IPv6NeighborTable; // Neighbor Discovery Table LIST *IPv6RouterAdvs; // Router offered prefixes UINT64 IPv6ClientEUI; // The EUI of the client (for the SLAAC autoconf) @@ -166,6 +188,7 @@ void IPCSendIPv4(IPC *ipc, void *data, UINT size); BLOCK *IPCRecvL2(IPC *ipc); BLOCK *IPCRecvIPv4(IPC *ipc); void IPCProcessInterrupts(IPC *ipc); +void IPCProcessL3EventsIPv4Only(IPC *ipc); void IPCProcessL3Events(IPC *ipc); void IPCProcessL3EventsEx(IPC *ipc, UINT64 now); bool IPCSetIPv4Parameters(IPC *ipc, IP *ip, IP *subnet, IP *gw, DHCP_CLASSLESS_ROUTE_TABLE *rt); @@ -202,11 +225,11 @@ void IPCIPv6AssociateOnNDT(IPC *ipc, IP *ip, UCHAR *mac_address); void IPCIPv6AssociateOnNDTEx(IPC *ipc, IP *ip, UCHAR *mac_address, bool isNeighborAdv); void IPCIPv6FlushNDT(IPC *ipc); void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now); -bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, IP *addr); +bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, UINT64 eui); // RA void IPCIPv6AddRouterPrefix(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip); bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVERTISEMENT *matchedRA); -void IPCIPv6SendRouterSolicitation(IPC *ipc); +UINT64 IPCIPv6GetServerEui(IPC *ipc); // Data flow BLOCK *IPCIPv6Recv(IPC *ipc); void IPCIPv6Send(IPC *ipc, void *data, UINT size); diff --git a/src/Cedar/Proto_OpenVPN.c b/src/Cedar/Proto_OpenVPN.c index c6acc5fa..fbce1940 100644 --- a/src/Cedar/Proto_OpenVPN.c +++ b/src/Cedar/Proto_OpenVPN.c @@ -259,13 +259,13 @@ void OvsLog(OPENVPN_SERVER *s, OPENVPN_SESSION *se, OPENVPN_CHANNEL *c, char *na if (c == NULL) { UniFormat(prefix, sizeof(prefix), _UU("LO_PREFIX_SESSION"), - se->Id, &se->ClientIp, se->ClientPort, &se->ServerIp, se->ServerPort); + se->Id, &se->ClientIp, se->ClientPort, &se->ServerIp, se->ServerPort); } else { UniFormat(prefix, sizeof(prefix), _UU("LO_PREFIX_CHANNEL"), - se->Id, &se->ClientIp, se->ClientPort, &se->ServerIp, se->ServerPort, - c->KeyId); + se->Id, &se->ClientIp, se->ClientPort, &se->ServerIp, se->ServerPort, + c->KeyId); } } va_start(args, name); @@ -617,10 +617,10 @@ void OvsProceccRecvPacket(OPENVPN_SERVER *s, UDPPACKET *p, UINT protocol) { // Control packet Debug("OvsProceccRecvPacket(): Received control packet. PacketId: %u, OpCode: %u, KeyId: %u, MySessionId: %I64u\n", - recv_packet->PacketId, recv_packet->OpCode, recv_packet->KeyId, recv_packet->MySessionId); + recv_packet->PacketId, recv_packet->OpCode, recv_packet->KeyId, recv_packet->MySessionId); if (recv_packet->OpCode == OPENVPN_P_CONTROL_HARD_RESET_CLIENT_V2 || - recv_packet->OpCode == OPENVPN_P_CONTROL_SOFT_RESET_V1) + recv_packet->OpCode == OPENVPN_P_CONTROL_SOFT_RESET_V1) { // Connection request packet if (c != NULL && c->Status == OPENVPN_CHANNEL_STATUS_ESTABLISHED) @@ -644,19 +644,19 @@ void OvsProceccRecvPacket(OPENVPN_SERVER *s, UDPPACKET *p, UINT protocol) OvsLog(s, se, c, "LO_NEW_CHANNEL"); } } -/* else if (recv_packet->OpCode == OPENVPN_P_CONTROL_SOFT_RESET_V1) - { - // Response to soft reset request packet - OPENVPN_PACKET *p; + /* else if (recv_packet->OpCode == OPENVPN_P_CONTROL_SOFT_RESET_V1) + { + // Response to soft reset request packet + OPENVPN_PACKET *p; - p = OvsNewControlPacket(OPENVPN_P_CONTROL_SOFT_RESET_V1, recv_packet->KeyId, se->ServerSessionId, - 0, NULL, 0, 0, 0, NULL); + p = OvsNewControlPacket(OPENVPN_P_CONTROL_SOFT_RESET_V1, recv_packet->KeyId, se->ServerSessionId, + 0, NULL, 0, 0, 0, NULL); - OvsSendPacketNow(s, se, p); + OvsSendPacketNow(s, se, p); - OvsFreePacket(p); - } -*/ + OvsFreePacket(p); + } + */ if (c != NULL) { // Delete the send packet list by looking the packet ID in the ACK list of arrived packet @@ -668,8 +668,8 @@ void OvsProceccRecvPacket(OPENVPN_SERVER *s, UDPPACKET *p, UINT protocol) InsertIntDistinct(c->AckReplyList, recv_packet->PacketId); if ((recv_packet->PacketId > c->MaxRecvPacketId) - || (recv_packet->OpCode == OPENVPN_P_CONTROL_HARD_RESET_CLIENT_V2) - || (recv_packet->OpCode == OPENVPN_P_CONTROL_SOFT_RESET_V1)) + || (recv_packet->OpCode == OPENVPN_P_CONTROL_HARD_RESET_CLIENT_V2) + || (recv_packet->OpCode == OPENVPN_P_CONTROL_SOFT_RESET_V1)) { c->MaxRecvPacketId = recv_packet->PacketId; @@ -743,12 +743,12 @@ void OvsDeleteFromSendingControlPacketList(OPENVPN_CHANNEL *c, UINT num_acks, UI } o = NewListFast(NULL); - for (i = 0;i < num_acks;i++) + for (i = 0; i < num_acks; i++) { UINT ack = acks[i]; UINT j; - for (j = 0;j < LIST_NUM(c->SendControlPacketList);j++) + for (j = 0; j < LIST_NUM(c->SendControlPacketList); j++) { OPENVPN_CONTROL_PACKET *p = LIST_DATA(c->SendControlPacketList, j); @@ -759,7 +759,7 @@ void OvsDeleteFromSendingControlPacketList(OPENVPN_CHANNEL *c, UINT num_acks, UI } } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { OPENVPN_CONTROL_PACKET *p = LIST_DATA(o, i); @@ -1119,7 +1119,7 @@ UINT OvsPeekStringFromFifo(FIFO *f, char *str, UINT str_size) StrCpy(str, str_size, ""); - for (i = 0;i < MIN(str_size, FifoSize(f));i++) + for (i = 0; i < MIN(str_size, FifoSize(f)); i++) { char c = *(((char *)FifoPtr(f)) + i); @@ -1267,8 +1267,8 @@ void OvsSetupSessionParameters(OPENVPN_SERVER *s, OPENVPN_SESSION *se, OPENVPN_C WriteBuf(b, c->ClientKey.Random1, sizeof(c->ClientKey.Random1)); WriteBuf(b, c->ServerKey.Random1, sizeof(c->ServerKey.Random1)); Enc_tls1_PRF(b->Buf, b->Size, - c->ClientKey.PreMasterSecret, sizeof(c->ClientKey.PreMasterSecret), - c->MasterSecret, sizeof(c->MasterSecret)); + c->ClientKey.PreMasterSecret, sizeof(c->ClientKey.PreMasterSecret), + c->MasterSecret, sizeof(c->MasterSecret)); FreeBuf(b); // Generate an Expansion Key @@ -1279,7 +1279,7 @@ void OvsSetupSessionParameters(OPENVPN_SERVER *s, OPENVPN_SESSION *se, OPENVPN_C WriteBufInt64(b, se->ClientSessionId); WriteBufInt64(b, se->ServerSessionId); Enc_tls1_PRF(b->Buf, b->Size, c->MasterSecret, sizeof(c->MasterSecret), - c->ExpansionKey, sizeof(c->ExpansionKey)); + c->ExpansionKey, sizeof(c->ExpansionKey)); FreeBuf(b); // Set up the encryption algorithm @@ -1314,13 +1314,13 @@ void OvsSetupSessionParameters(OPENVPN_SERVER *s, OPENVPN_SESSION *se, OPENVPN_C // Generate the response option string Format(c->ServerKey.OptionString, sizeof(c->ServerKey.OptionString), - "V4,dev-type %s,link-mtu %u,tun-mtu %u,proto %s," - "cipher %s,auth %s,keysize %u,key-method 2,tls-server", - (se->Mode == OPENVPN_MODE_L2 ? "tap" : "tun"), - se->LinkMtu, - se->TunMtu, - c->Proto, - cipher_name, md_name, c->CipherEncrypt->KeySize * 8); + "V4,dev-type %s,link-mtu %u,tun-mtu %u,proto %s," + "cipher %s,auth %s,keysize %u,key-method 2,tls-server", + (se->Mode == OPENVPN_MODE_L2 ? "tap" : "tun"), + se->LinkMtu, + se->TunMtu, + c->Proto, + cipher_name, md_name, c->CipherEncrypt->KeySize * 8); FreeEntryList(o); @@ -1482,13 +1482,13 @@ UINT OvsParseKeyMethod2(OPENVPN_KEY_METHOD_2 *ret, UCHAR *data, UINT size, bool { // String if (OvsReadStringFromBuf(b, ret->OptionString, sizeof(ret->OptionString)) && - OvsReadStringFromBuf(b, ret->Username, sizeof(ret->Username)) && - OvsReadStringFromBuf(b, ret->Password, sizeof(ret->Password))) + OvsReadStringFromBuf(b, ret->Username, sizeof(ret->Username)) && + OvsReadStringFromBuf(b, ret->Password, sizeof(ret->Password))) + { + if (!OvsReadStringFromBuf(b, ret->PeerInfo, sizeof(ret->PeerInfo))) { - if (!OvsReadStringFromBuf(b, ret->PeerInfo, sizeof(ret->PeerInfo))) - { - Zero(ret->PeerInfo, sizeof(ret->PeerInfo)); - } + Zero(ret->PeerInfo, sizeof(ret->PeerInfo)); + } read_size = b->Current; } } @@ -1637,7 +1637,7 @@ UINT OvsGetAckReplyList(OPENVPN_CHANNEL *c, UINT *ret) num = MIN(LIST_NUM(c->AckReplyList), OPENVPN_MAX_NUMACK); - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { UINT *v = LIST_DATA(c->AckReplyList, i); @@ -1651,7 +1651,7 @@ UINT OvsGetAckReplyList(OPENVPN_CHANNEL *c, UINT *ret) ret[i] = *v; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { UINT *v = LIST_DATA(o, i); @@ -1682,7 +1682,7 @@ void OvsFreeChannel(OPENVPN_CHANNEL *c) ReleaseIntList(c->AckReplyList); - for (i = 0;i < LIST_NUM(c->SendControlPacketList);i++) + for (i = 0; i < LIST_NUM(c->SendControlPacketList); i++) { OPENVPN_CONTROL_PACKET *p = LIST_DATA(c->SendControlPacketList, i); @@ -1758,7 +1758,7 @@ UINT64 OvsNewServerSessionId(OPENVPN_SERVER *s) continue; } - for (i = 0;i < LIST_NUM(s->SessionList);i++) + for (i = 0; i < LIST_NUM(s->SessionList); i++) { OPENVPN_SESSION *se = LIST_DATA(s->SessionList, i); if (se->ServerSessionId == id) @@ -1882,7 +1882,7 @@ BUF *OvsBuildPacket(OPENVPN_PACKET *p) { UINT i; - for (i = 0;i < num_ack;i++) + for (i = 0; i < num_ack; i++) { WriteBufInt(b, (UCHAR)p->AckPacketId[i]); } @@ -1970,7 +1970,7 @@ OPENVPN_PACKET *OvsParsePacket(UCHAR *data, UINT size) goto LABEL_ERROR; } - for (i = 0;i < ret->NumAck;i++) + for (i = 0; i < ret->NumAck; i++) { UINT ui; @@ -2066,7 +2066,7 @@ UINT OvsGetNumSessionByClientIp(OPENVPN_SERVER *s, IP *ip) return 0; } - for (i = 0;i < LIST_NUM(s->SessionList);i++) + for (i = 0; i < LIST_NUM(s->SessionList); i++) { OPENVPN_SESSION *se = LIST_DATA(s->SessionList, i); @@ -2130,7 +2130,7 @@ OPENVPN_SESSION *OvsNewSession(OPENVPN_SERVER *s, IP *server_ip, UINT server_por IPToStr(server_ip_str, sizeof(server_ip_str), server_ip); IPToStr(client_ip_str, sizeof(client_ip_str), client_ip); Debug("OpenVPN New Session: %s:%u -> %s:%u Proto=%u\n", server_ip_str, server_port, - client_ip_str, client_port, protocol); + client_ip_str, client_port, protocol); OvsLog(s, se, NULL, "LO_NEW_SESSION", (protocol == OPENVPN_PROTOCOL_UDP ? "UDP" : "TCP")); @@ -2159,13 +2159,14 @@ void OvsFreeSession(OPENVPN_SESSION *se) UINTToIP(&dhcp_ip, se->IpcAsync->L3ClientAddressOption.ServerAddress); IPCDhcpFreeIP(se->Ipc, &dhcp_ip); - IPCProcessL3Events(se->Ipc); + IPC_PROTO_SET_STATUS(se->Ipc, IPv6State, IPC_PROTO_STATUS_CLOSED); + IPCProcessL3EventsIPv4Only(se->Ipc); } } } // Release the channel - for (i = 0;i < OPENVPN_NUM_CHANNELS;i++) + for (i = 0; i < OPENVPN_NUM_CHANNELS; i++) { OPENVPN_CHANNEL *c = se->Channels[i]; @@ -2225,7 +2226,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) s->Now = Tick64(); // Process for all sessions - for (i = 0;i < LIST_NUM(s->SessionList);i++) + for (i = 0; i < LIST_NUM(s->SessionList); i++) { OPENVPN_SESSION *se = LIST_DATA(s->SessionList, i); @@ -2240,7 +2241,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) } // Process received packets - for (i = 0;i < LIST_NUM(recv_packet_list);i++) + for (i = 0; i < LIST_NUM(recv_packet_list); i++) { UDPPACKET *p = LIST_DATA(recv_packet_list, i); @@ -2248,7 +2249,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) } // Treat for all sessions and all channels - for (i = 0;i < LIST_NUM(s->SessionList);i++) + for (i = 0; i < LIST_NUM(s->SessionList); i++) { OPENVPN_CHANNEL *latest_channel = NULL; UINT64 max_tick = 0; @@ -2259,11 +2260,11 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) { if (se->Mode == OPENVPN_MODE_L3) { - IPCProcessL3Events(se->Ipc); + IPCProcessL3EventsIPv4Only(se->Ipc); } } - for (j = 0;j < OPENVPN_NUM_CHANNELS;j++) + for (j = 0; j < OPENVPN_NUM_CHANNELS; j++) { OPENVPN_CHANNEL *c = se->Channels[j]; @@ -2320,9 +2321,9 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) // Return the PUSH_REPLY Format(option_str, sizeof(option_str), - "PUSH_REPLY,ping %u,ping-restart %u", - (OPENVPN_PING_SEND_INTERVAL / 1000), - (OPENVPN_RECV_TIMEOUT / 1000)); + "PUSH_REPLY,ping %u,ping-restart %u", + (OPENVPN_PING_SEND_INTERVAL / 1000), + (OPENVPN_RECV_TIMEOUT / 1000)); if (se->Mode == OPENVPN_MODE_L3) { @@ -2344,26 +2345,26 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) ClearStr(ip_defgw, sizeof(ip_defgw)); IPToStr32(ip_client, sizeof(ip_client), - cao->ClientAddress); + cao->ClientAddress); IPToStr32(ip_subnet_mask, sizeof(ip_subnet_mask), - cao->SubnetMask); + cao->SubnetMask); Format(l3_options, sizeof(l3_options), - ",topology subnet"); + ",topology subnet"); StrCat(option_str, sizeof(option_str), l3_options); Format(l3_options, sizeof(l3_options), - ",ifconfig %s %s", - ip_client, - ip_subnet_mask); + ",ifconfig %s %s", + ip_client, + ip_subnet_mask); StrCat(option_str, sizeof(option_str), l3_options); // Domain name if (IsEmptyStr(cao->DomainName) == false) { Format(l3_options, sizeof(l3_options), - ",dhcp-option DOMAIN %s", cao->DomainName); + ",dhcp-option DOMAIN %s", cao->DomainName); StrCat(option_str, sizeof(option_str), l3_options); } @@ -2373,7 +2374,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) char ip_str[64]; IPToStr32(ip_str, sizeof(ip_str), cao->DnsServer); Format(l3_options, sizeof(l3_options), - ",dhcp-option DNS %s", ip_str); + ",dhcp-option DNS %s", ip_str); StrCat(option_str, sizeof(option_str), l3_options); StrCpy(ip_dns1, sizeof(ip_dns1), ip_str); @@ -2385,7 +2386,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) char ip_str[64]; IPToStr32(ip_str, sizeof(ip_str), cao->DnsServer2); Format(l3_options, sizeof(l3_options), - ",dhcp-option DNS %s", ip_str); + ",dhcp-option DNS %s", ip_str); StrCat(option_str, sizeof(option_str), l3_options); StrCpy(ip_dns2, sizeof(ip_dns2), ip_str); @@ -2397,7 +2398,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) char ip_str[64]; IPToStr32(ip_str, sizeof(ip_str), cao->WinsServer); Format(l3_options, sizeof(l3_options), - ",dhcp-option WINS %s", ip_str); + ",dhcp-option WINS %s", ip_str); StrCat(option_str, sizeof(option_str), l3_options); StrCpy(ip_wins1, sizeof(ip_wins1), ip_str); @@ -2409,7 +2410,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) char ip_str[64]; IPToStr32(ip_str, sizeof(ip_str), cao->WinsServer2); Format(l3_options, sizeof(l3_options), - ",dhcp-option WINS %s", ip_str); + ",dhcp-option WINS %s", ip_str); StrCat(option_str, sizeof(option_str), l3_options); StrCpy(ip_wins2, sizeof(ip_wins2), ip_str); @@ -2421,7 +2422,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) char ip_str[64]; IPToStr32(ip_str, sizeof(ip_str), cao->Gateway); Format(l3_options, sizeof(l3_options), - ",route-gateway %s,redirect-gateway def1", ip_str); + ",route-gateway %s,redirect-gateway def1", ip_str); StrCat(option_str, sizeof(option_str), l3_options); StrCpy(ip_defgw, sizeof(ip_defgw), ip_str); @@ -2442,9 +2443,9 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) IPAnd4(&local_network, &client_ip, &subnet_mask); Format(l3_options, sizeof(l3_options), - ",route %r %r vpn_gateway", - &local_network, - &cao->SubnetMask); + ",route %r %r vpn_gateway", + &local_network, + &cao->SubnetMask); StrCat(option_str, sizeof(option_str), l3_options); #endif @@ -2454,15 +2455,15 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) if (cao->ClasslessRoute.NumExistingRoutes >= 1) { UINT i; - for (i = 0;i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES;i++) + for (i = 0; i < MAX_DHCP_CLASSLESS_ROUTE_ENTRIES; i++) { DHCP_CLASSLESS_ROUTE *r = &cao->ClasslessRoute.Entries[i]; if (r->Exists) { Format(l3_options, sizeof(l3_options), - ",route %r %r vpn_gateway", - &r->Network, &r->SubnetMask); + ",route %r %r vpn_gateway", + &r->Network, &r->SubnetMask); StrCat(option_str, sizeof(option_str), l3_options); } @@ -2470,7 +2471,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) } OvsLog(s, se, c, "LP_SET_IPV4_PARAM", - ip_client, ip_subnet_mask, ip_defgw, ip_dns1, ip_dns2, ip_wins1, ip_wins2); + ip_client, ip_subnet_mask, ip_defgw, ip_dns1, ip_dns2, ip_wins1, ip_wins2); } else { @@ -2579,8 +2580,8 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) Debug("RawOut Fifo Size (c=%u): %u\n", c->KeyId, FifoSize(c->SslPipe->RawOut->RecvFifo)); OvsSendControlPacketWithAutoSplit(c, OPENVPN_P_CONTROL_V1, - FifoPtr(c->SslPipe->RawOut->RecvFifo), - FifoSize(c->SslPipe->RawOut->RecvFifo)); + FifoPtr(c->SslPipe->RawOut->RecvFifo), + FifoSize(c->SslPipe->RawOut->RecvFifo)); ReadFifo(c->SslPipe->RawOut->RecvFifo, NULL, FifoSize(c->SslPipe->RawOut->RecvFifo)); } @@ -2594,7 +2595,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) UINT k; // Packet transmission - for (k = 0;k < LIST_NUM(c->SendControlPacketList);k++) + for (k = 0; k < LIST_NUM(c->SendControlPacketList); k++) { OPENVPN_CONTROL_PACKET *cp = LIST_DATA(c->SendControlPacketList, k); @@ -2609,7 +2610,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) num = OvsGetAckReplyList(c, acks); p = OvsNewControlPacket(cp->OpCode, j, se->ServerSessionId, num, acks, - se->ClientSessionId, cp->PacketId, cp->DataSize, cp->Data); + se->ClientSessionId, cp->PacketId, cp->DataSize, cp->Data); OvsSendPacketNow(s, se, p); @@ -2628,7 +2629,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) if (num >= 1) { OPENVPN_PACKET *p = OvsNewControlPacket(OPENVPN_P_ACK_V1, j, se->ServerSessionId, - num, acks, se->ClientSessionId, 0, 0, NULL); + num, acks, se->ClientSessionId, 0, 0, NULL); OvsSendPacketNow(s, se, p); @@ -2656,14 +2657,14 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) } } - IPCProcessL3Events(se->Ipc); + IPCProcessL3EventsIPv4Only(se->Ipc); } IPCProcessInterrupts(se->Ipc); } // Choose the latest channel in all established channels - for (j = 0;j < OPENVPN_NUM_CHANNELS;j++) + for (j = 0; j < OPENVPN_NUM_CHANNELS; j++) { OPENVPN_CHANNEL *c = se->Channels[j]; @@ -2733,7 +2734,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) se->NextPingSendTick = s->Now + (UINT64)(OPENVPN_PING_SEND_INTERVAL); OvsSendDataPacket(latest_channel, latest_channel->KeyId, ++latest_channel->LastDataPacketId, - ping_signature, sizeof(ping_signature)); + ping_signature, sizeof(ping_signature)); //Debug("."); AddInterrupt(s->Interrupt, se->NextPingSendTick); @@ -2765,7 +2766,7 @@ void OvsRecvPacket(OPENVPN_SERVER *s, LIST *recv_packet_list, UINT protocol) { UINT i; - for (i = 0;i < LIST_NUM(delete_session_list);i++) + for (i = 0; i < LIST_NUM(delete_session_list); i++) { OPENVPN_SESSION *se = LIST_DATA(delete_session_list, i); @@ -2798,7 +2799,7 @@ void OvsSendPacketNow(OPENVPN_SERVER *s, OPENVPN_SESSION *se, OPENVPN_PACKET *p) if (p->NumAck >= 1) { Debug("Sending ACK Packet IDs (c=%u): ", p->KeyId); - for (i = 0;i < p->NumAck;i++) + for (i = 0; i < p->NumAck; i++) { Debug("%u ", p->AckPacketId[i]); } @@ -2844,14 +2845,14 @@ void OvsSendPacketRawNow(OPENVPN_SERVER *s, OPENVPN_SESSION *se, void *data, UIN } u = NewUdpPacket(&se->ServerIp, se->ServerPort, &se->ClientIp, se->ClientPort, - data, size); + data, size); Add(s->SendPacketList, u); } // Create a new OpenVPN control packet OPENVPN_PACKET *OvsNewControlPacket(UCHAR opcode, UCHAR key_id, UINT64 my_channel_id, UINT num_ack, - UINT *ack_packet_ids, UINT64 your_channel_id, UINT packet_id, - UINT data_size, UCHAR *data) + UINT *ack_packet_ids, UINT64 your_channel_id, UINT packet_id, + UINT data_size, UCHAR *data) { OPENVPN_PACKET *p = ZeroMalloc(sizeof(OPENVPN_PACKET)); UINT i; @@ -2861,7 +2862,7 @@ OPENVPN_PACKET *OvsNewControlPacket(UCHAR opcode, UCHAR key_id, UINT64 my_channe p->MySessionId = my_channel_id; p->NumAck = num_ack; - for (i = 0;i < MIN(num_ack, OPENVPN_MAX_NUMACK);i++) + for (i = 0; i < MIN(num_ack, OPENVPN_MAX_NUMACK); i++) { p->AckPacketId[i] = ack_packet_ids[i]; } diff --git a/src/Cedar/Proto_PPP.c b/src/Cedar/Proto_PPP.c index b165c350..c7af4310 100644 --- a/src/Cedar/Proto_PPP.c +++ b/src/Cedar/Proto_PPP.c @@ -12,9 +12,6 @@ void PPPThread(THREAD *thread, void *param) { PPP_SESSION *p = (PPP_SESSION *)param; UINT i; - PPP_LCP *c; - USHORT us; - UINT ui; USHORT next_protocol = 0; bool ret = false; char ipstr1[128], ipstr2[128]; @@ -32,8 +29,6 @@ void PPPThread(THREAD *thread, void *param) Debug("PPP Initialize"); PPPSetStatus(p, PPP_STATUS_CONNECTED); - p->IPv4_State = PPP_PROTO_STATUS_CLOSED; - p->IPv6_State = PPP_PROTO_STATUS_CLOSED; p->Eap_Protocol = PPP_UNSPECIFIED; @@ -181,7 +176,8 @@ void PPPThread(THREAD *thread, void *param) { UINT64 nowL; // Here client to server - if (p->CurrentPacket->Protocol == PPP_PROTOCOL_IP && p->IPv4_State == PPP_PROTO_STATUS_OPENED) + if (p->CurrentPacket->Protocol == PPP_PROTOCOL_IP && + IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_OPENED) { receivedPacketProcessed = true; IPCSendIPv4(p->Ipc, p->CurrentPacket->Data, p->CurrentPacket->DataSize); @@ -190,10 +186,11 @@ void PPPThread(THREAD *thread, void *param) { Debug("Got IPv4 packet before IPv4 ready!\n"); } - else if (p->CurrentPacket->Protocol == PPP_PROTOCOL_IPV6 && p->IPv6_State == PPP_PROTO_STATUS_OPENED) + else if (p->CurrentPacket->Protocol == PPP_PROTOCOL_IPV6 && + IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) == IPC_PROTO_STATUS_OPENED) { receivedPacketProcessed = true; - Debug("IPv6 to be implemented\n"); + IPCIPv6Send(p->Ipc, p->CurrentPacket->Data, p->CurrentPacket->DataSize); } else if (p->CurrentPacket->Protocol == PPP_PROTOCOL_IPV6) { @@ -318,18 +315,21 @@ void PPPThread(THREAD *thread, void *param) if (p->PPPStatus == PPP_STATUS_NETWORK_LAYER) { UINT64 timeBeforeLoop; - if (p->DhcpAllocated) + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_OPENED) { - if (now >= p->DhcpNextRenewTime) + if (p->DhcpAllocated) { - IP ip; + if (now >= p->DhcpNextRenewTime) + { + IP ip; - // DHCP renewal procedure - p->DhcpNextRenewTime = now + p->DhcpRenewInterval; + // DHCP renewal procedure + p->DhcpNextRenewTime = now + p->DhcpRenewInterval; - UINTToIP(&ip, p->ClientAddressOption.ServerAddress); + UINTToIP(&ip, p->ClientAddressOption.ServerAddress); - IPCDhcpRenewIP(p->Ipc, &ip); + IPCDhcpRenewIP(p->Ipc, &ip); + } } } @@ -340,30 +340,73 @@ void PPPThread(THREAD *thread, void *param) while (true) { UINT64 nowL; - BLOCK *b = IPCRecvIPv4(p->Ipc); - PPP_PACKET *pp; - PPP_PACKET tmp; - if (b == NULL) + bool no4packets = false; + bool no6packets = false; + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_OPENED) { - break; + BLOCK *b = IPCRecvIPv4(p->Ipc); + if (b == NULL) + { + no4packets = true; + } + else + { + PPP_PACKET *pp; + PPP_PACKET tmp; + + // Since receiving the IP packet, send it to the client by PPP + pp = &tmp; + pp->IsControl = false; + pp->Protocol = PPP_PROTOCOL_IP; + pp->Lcp = NULL; + pp->Data = b->Buf; + pp->DataSize = b->Size; + + PPPSendPacketEx(p, pp, true); + + FreePPPPacketEx(pp, true); + Free(b); + } + } + else + { + no4packets = true; } - // Since receiving the IP packet, send it to the client by PPP - pp = &tmp; - pp->IsControl = false; - pp->Protocol = PPP_PROTOCOL_IP; - pp->Lcp = NULL; - pp->Data = b->Buf; - pp->DataSize = b->Size; + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) == IPC_PROTO_STATUS_OPENED) + { + BLOCK *b = IPCIPv6Recv(p->Ipc); + if (b == NULL) + { + no6packets = true; + } + else + { + PPP_PACKET *pp; + PPP_PACKET tmp; - PPPSendPacketEx(p, pp, true); + // Since receiving the IP packet, send it to the client by PPP + pp = &tmp; + pp->IsControl = false; + pp->Protocol = PPP_PROTOCOL_IPV6; + pp->Lcp = NULL; + pp->Data = b->Buf; + pp->DataSize = b->Size; - FreePPPPacketEx(pp, true); - Free(b); + PPPSendPacketEx(p, pp, true); + + FreePPPPacketEx(pp, true); + Free(b); + } + } + else + { + no6packets = true; + } // Let's break out of the loop once in a while so we don't get stuck here endlessly nowL = Tick64(); - if (nowL > timeBeforeLoop + PPP_PACKET_RESEND_INTERVAL) + if (nowL > timeBeforeLoop + PPP_PACKET_RESEND_INTERVAL || (no4packets && no6packets)) { break; } @@ -743,7 +786,7 @@ bool PPPProcessResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req) return PPPProcessIPCPResponsePacket(p, pp, req); break; case PPP_PROTOCOL_IPV6CP: - Debug("IPv6CP to be implemented\n"); + return PPPProcessIPv6CPResponsePacket(p, pp, req); break; case PPP_PROTOCOL_EAP: return PPPProcessEAPResponsePacket(p, pp, req); @@ -786,11 +829,11 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req USHORT *protocol = pp->Lcp->Data; if (*protocol == PPP_PROTOCOL_IPCP || *protocol == PPP_PROTOCOL_IP) { - p->IPv4_State = PPP_PROTO_STATUS_REJECTED; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_REJECTED); } if (*protocol == PPP_PROTOCOL_IPV6CP || *protocol == PPP_PROTOCOL_IPV6) { - p->IPv6_State = PPP_PROTO_STATUS_REJECTED; + IPC_PROTO_SET_STATUS(p->Ipc, IPv6State, IPC_PROTO_STATUS_REJECTED); } } } @@ -1082,7 +1125,7 @@ bool PPPProcessIPCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re if (!PPPGetIPAddressValueFromLCP(pp->Lcp, PPP_IPCP_OPTION_IP, &addrStruct) || pp->Lcp->Code == PPP_LCP_CODE_REJECT || pp->Lcp->Code == PPP_LCP_CODE_CODE_REJECT) { Debug("Unsupported IPCP protocol"); - p->IPv4_State = PPP_PROTO_STATUS_REJECTED; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_REJECTED); PPPRejectUnsupportedPacketEx(p, pp, true); return false; } @@ -1096,14 +1139,14 @@ bool PPPProcessIPCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re Debug("Accepted server IP address of %s\n", addrStr); // We already configured client address, now server address is also confirmed, ready for IPv4 data flow - if (p->IPv4_State == PPP_PROTO_STATUS_CONFIG) + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_CONFIG) { - p->IPv4_State = PPP_PROTO_STATUS_CONFIG_WAIT; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_CONFIG_WAIT); } return true; } - p->IPv4_State = PPP_PROTO_STATUS_CONFIG; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_CONFIG); PPPGetIPAddressValueFromLCP(req->Lcp, PPP_IPCP_OPTION_IP, &prevAddrStruct); prevAddr = IPToUINT(&prevAddrStruct); @@ -1115,7 +1158,7 @@ bool PPPProcessIPCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *re if (prevAddr == Endian32(0xc0000008)) { Debug("We already tried the fallback IP of 192.0.0.8, giving up\n"); - p->IPv4_State = PPP_PROTO_STATUS_REJECTED; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_REJECTED); PPPRejectUnsupportedPacketEx(p, pp, true); return false; } @@ -1205,6 +1248,31 @@ bool PPPProcessEAPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req return false; } +// Process IPv6CP responses +bool PPPProcessIPv6CPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req) +{ + bool isAccepted = !PPP_LCP_CODE_IS_NEGATIVE(pp->Lcp->Code); + + // If we got a reject or a NACK, we just reject the whole IPv6 configuration, there is no way we can recover even from a NACK as we can't change the link-local address of an already existing router + if (!isAccepted) + { + Debug("Unsupported IPv6CP protocol"); + IPC_PROTO_SET_STATUS(p->Ipc, IPv6State, IPC_PROTO_STATUS_REJECTED); + PPPRejectUnsupportedPacketEx(p, pp, true); + return false; + } + + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) != IPC_PROTO_STATUS_CONFIG) + { + Debug("We got an early IPv6CP response, ignoring for now...\n"); + return false; + } + + Debug("Accepted server IPv6CP handshake\n"); + IPC_PROTO_SET_STATUS(p->Ipc, IPv6State, IPC_PROTO_STATUS_CONFIG_WAIT); + return true; +} + // Processes request packets bool PPPProcessRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) @@ -1227,8 +1295,7 @@ bool PPPProcessRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) return PPPProcessIPCPRequestPacket(p, pp); break; case PPP_PROTOCOL_IPV6CP: - PPPRejectUnsupportedPacketEx(p, pp, true); - Debug("IPv6CP to be implemented\n"); + return PPPProcessIPv6CPRequestPacket(p, pp); break; case PPP_PROTOCOL_EAP: return PPPProcessEAPRequestPacket(p, pp); @@ -1547,9 +1614,8 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) bool ok = true; bool processed = false; bool isEmptyIpAddress = false; - PPP_LCP *c; - if (p->IPv4_State == PPP_PROTO_STATUS_REJECTED) + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_REJECTED) { Debug("We got an IPCP packet after we had it rejected\n"); return PPPRejectUnsupportedPacketEx(p, pp, true); @@ -1823,7 +1889,7 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) // We will delay this packet ACK and send the server IP first, then wait for a reparse // it is kind of dirty but fixes issues on some clients (namely VPN Client Pro on Android) - if (p->IPv4_State == PPP_PROTO_STATUS_CLOSED && p->ClientAddressOption.ServerAddress != 0 && ok) + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_CLOSED && p->ClientAddressOption.ServerAddress != 0 && ok) { PPP_LCP *c = NewPPPLCP(PPP_LCP_CODE_REQ, 0); UINT ui = p->ClientAddressOption.ServerAddress; @@ -1834,7 +1900,7 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) WHERE; return false; } - p->IPv4_State = PPP_PROTO_STATUS_CONFIG; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_CONFIG); if (!processed) { PPPAddNextPacket(p, pp, 1); @@ -1843,7 +1909,8 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) } // We still haven't received any answer from client about server IP, keep waiting... - if ((p->IPv4_State == PPP_PROTO_STATUS_CONFIG || p->IPv4_State == PPP_PROTO_STATUS_CLOSED) && !processed) + if ((IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_CONFIG || + IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_CLOSED) && !processed) { PPPAddNextPacket(p, pp, 1); return false; @@ -1856,9 +1923,9 @@ bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) } Debug("ACKed IPCP options ID = 0x%x\n", pp->Lcp->Id); - if (ok && p->IPv4_State == PPP_PROTO_STATUS_CONFIG_WAIT) + if (ok && IPC_PROTO_GET_STATUS(p->Ipc, IPv4State) == IPC_PROTO_STATUS_CONFIG_WAIT) { - p->IPv4_State = PPP_PROTO_STATUS_OPENED; + IPC_PROTO_SET_STATUS(p->Ipc, IPv4State, IPC_PROTO_STATUS_OPENED); Debug("IPv4 OPENED\n"); } return ok; @@ -1871,6 +1938,116 @@ bool PPPProcessEAPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) return false; } +// Process IPv6CP request packets +bool PPPProcessIPv6CPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) +{ + UINT i; + bool processed = false; + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) == IPC_PROTO_STATUS_REJECTED) + { + Debug("We got an IPv6CP packet after we had it rejected\n"); + return PPPRejectUnsupportedPacketEx(p, pp, true); + } + + for (i = 0; i < LIST_NUM(pp->Lcp->OptionList); i++) + { + PPP_OPTION *t = LIST_DATA(pp->Lcp->OptionList, i); + + switch (t->Type) + { + case PPP_IPV6CP_OPTION_EUI: + t->IsSupported = true; + if (t->DataSize == sizeof(UINT64)) + { + UINT64 newValue = 0; + UINT64 value = READ_UINT64(t->Data); + if (!IPCIPv6CheckExistingLinkLocal(p->Ipc, value)) + { + t->IsAccepted = true; + p->Ipc->IPv6ClientEUI = value; + } + else + { + t->IsAccepted = false; + GenerateEui64Address6((UCHAR *)&newValue, p->Ipc->MacAddress); + if (newValue != value && !IPCIPv6CheckExistingLinkLocal(p->Ipc, newValue)) + { + WRITE_UINT64(t->AltData, newValue); + t->AltDataSize = sizeof(UINT64); + } + else + { + while (true) + { + newValue = Rand64(); + if (!IPCIPv6CheckExistingLinkLocal(p->Ipc, newValue)) + { + WRITE_UINT64(t->AltData, newValue); + t->AltDataSize = sizeof(UINT64); + break; + } + } + } + } + } + break; + default: + t->IsSupported = false; + break; + } + } + + if (PPPRejectLCPOptionsEx(p, pp, processed)) + { + Debug("Rejected IPv6CP options ID = 0x%x\n", pp->Lcp->Id); + processed = true; + } + + if (PPPNackLCPOptionsEx(p, pp, processed)) + { + Debug("NACKed IPv6CP options ID = 0x%x\n", pp->Lcp->Id); + processed = true; + } + + if (p->Ipc->IPv6ClientEUI != 0 && IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) == IPC_PROTO_STATUS_CLOSED) + { + PPP_LCP *c = NewPPPLCP(PPP_LCP_CODE_REQ, 0); + UINT64 serverEui = IPCIPv6GetServerEui(p->Ipc); + if (serverEui != 0 && serverEui != p->Ipc->IPv6ClientEUI) + { + Add(c->OptionList, NewPPPOption(PPP_IPV6CP_OPTION_EUI, &serverEui, sizeof(UINT64))); + } + if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_IPV6CP, c)) + { + PPPSetStatus(p, PPP_STATUS_FAIL); + WHERE; + return false; + } + + IPC_PROTO_SET_STATUS(p->Ipc, IPv6State, IPC_PROTO_STATUS_CONFIG); + } + + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) == IPC_PROTO_STATUS_CONFIG && !processed) + { + PPPAddNextPacket(p, pp, 1); + return false; + } + + if (!PPPAckLCPOptionsEx(p, pp, processed)) + { + return false; + } + Debug("ACKed IPv6CP options ID = 0x%x\n", pp->Lcp->Id); + + if (IPC_PROTO_GET_STATUS(p->Ipc, IPv6State) == IPC_PROTO_STATUS_CONFIG_WAIT) + { + IPC_PROTO_SET_STATUS(p->Ipc, IPv6State, IPC_PROTO_STATUS_OPENED); + Debug("IPv6 OPENED\n"); + } + + return true; +} + // LCP option based packets utility bool PPPRejectLCPOptions(PPP_SESSION *p, PPP_PACKET *pp) { @@ -2128,7 +2305,7 @@ LABEL_LOOP: if (async == false) { - d = TubeRecvSync(p->TubeRecv, p->PacketRecvTimeout); + d = TubeRecvSync(p->TubeRecv, (UINT)p->PacketRecvTimeout); } else { @@ -2241,7 +2418,6 @@ PPP_PACKET *PPPGetNextPacket(PPP_SESSION *p) void PPPAddNextPacket(PPP_SESSION *p, PPP_PACKET *pp, UINT delay) { PPP_DELAYED_PACKET *t = ZeroMalloc(sizeof(PPP_DELAYED_PACKET)); - UINT i; if (p->CurrentPacket == pp) { p->CurrentPacket = NULL; @@ -2262,7 +2438,7 @@ void PPPAddNextPacket(PPP_SESSION *p, PPP_PACKET *pp, UINT delay) Debug("after sorting delayeds end\n");*/ } -int PPPDelayedPacketsComparator(const void *a, const void *b) +int PPPDelayedPacketsComparator(void *a, void *b) { PPP_DELAYED_PACKET *first = a; PPP_DELAYED_PACKET *second = b; @@ -3009,12 +3185,11 @@ bool PPPProcessEAPTlsResponse(PPP_SESSION *p, PPP_EAP *eap_packet, UINT eapTlsSi UCHAR *dataBuffer; UINT dataSize; UINT tlsLength = 0; - UINT i; bool isFragmented = false; PPP_LCP *lcp; PPP_EAP *eap; UCHAR flags = PPP_EAP_TLS_FLAG_NONE; - UINT64 sizeLeft = 0; + UINT sizeLeft = 0; Debug("Got EAP-TLS size=%i\n", eapTlsSize); if (eapTlsSize == 1) { @@ -3024,7 +3199,7 @@ bool PPPProcessEAPTlsResponse(PPP_SESSION *p, PPP_EAP *eap_packet, UINT eapTlsSi // We got an ACK to transmit the next fragmented message dataSize = p->Mru1 - 8 - 1 - 1; // Calculating the maximum payload size (without TlsLength) sizeLeft = GetMemSize(p->Eap_TlsCtx.CachedBufferSend); - sizeLeft -= p->Eap_TlsCtx.CachedBufferSendPntr - p->Eap_TlsCtx.CachedBufferSend; + sizeLeft -= (UINT)(p->Eap_TlsCtx.CachedBufferSendPntr - p->Eap_TlsCtx.CachedBufferSend); flags = PPP_EAP_TLS_FLAG_FRAGMENTED; // M flag if (dataSize > sizeLeft) @@ -3035,7 +3210,7 @@ bool PPPProcessEAPTlsResponse(PPP_SESSION *p, PPP_EAP *eap_packet, UINT eapTlsSi lcp = BuildEAPTlsRequest(p->Eap_PacketId++, dataSize, flags); eap = lcp->Data; Copy(eap->Tls.TlsDataWithoutLength, p->Eap_TlsCtx.CachedBufferSendPntr, dataSize); - p->Eap_TlsCtx.CachedBufferSendPntr += dataSize; + p->Eap_TlsCtx.CachedBufferSendPntr += (UINT64)dataSize; if (!PPPSendAndRetransmitRequest(p, PPP_PROTOCOL_EAP, lcp)) { @@ -3192,7 +3367,7 @@ bool PPPProcessEAPTlsResponse(PPP_SESSION *p, PPP_EAP *eap_packet, UINT eapTlsSi p->Eap_TlsCtx.CachedBufferRecvPntr = p->Eap_TlsCtx.CachedBufferRecv; } sizeLeft = GetMemSize(p->Eap_TlsCtx.CachedBufferRecv); - sizeLeft -= p->Eap_TlsCtx.CachedBufferRecvPntr - p->Eap_TlsCtx.CachedBufferRecv; + sizeLeft -= (UINT)(p->Eap_TlsCtx.CachedBufferRecvPntr - p->Eap_TlsCtx.CachedBufferRecv); Copy(p->Eap_TlsCtx.CachedBufferRecvPntr, dataBuffer, MIN(sizeLeft, dataSize)); @@ -3206,7 +3381,7 @@ bool PPPProcessEAPTlsResponse(PPP_SESSION *p, PPP_EAP *eap_packet, UINT eapTlsSi dataSize = GetMemSize(p->Eap_TlsCtx.CachedBufferRecv); if (dataSize == MAX_BUFFERING_PACKET_SIZE) { - dataSize = p->Eap_TlsCtx.CachedBufferRecvPntr - p->Eap_TlsCtx.CachedBufferRecv; + dataSize = (UINT)(p->Eap_TlsCtx.CachedBufferRecvPntr - p->Eap_TlsCtx.CachedBufferRecv); } } diff --git a/src/Cedar/Proto_PPP.h b/src/Cedar/Proto_PPP.h index 9c261bed..4cf8c9fe 100644 --- a/src/Cedar/Proto_PPP.h +++ b/src/Cedar/Proto_PPP.h @@ -95,7 +95,7 @@ #define PPP_IPCP_OPTION_WINS2 132 // IPV6CP option type -#define PPP_IPV6CP_OPTION_IID 1 +#define PPP_IPV6CP_OPTION_EUI 1 // EAP codes #define PPP_EAP_CODE_REQUEST 1 @@ -135,13 +135,6 @@ #define PPP_STATUS_FAIL 0x1000 #define PPP_STATUS_AUTH_FAIL 0x1010 -// Protocol status -#define PPP_PROTO_STATUS_CLOSED 0x0 -#define PPP_PROTO_STATUS_CONFIG 0x1 -#define PPP_PROTO_STATUS_CONFIG_WAIT 0x2 -#define PPP_PROTO_STATUS_OPENED 0x10 -#define PPP_PROTO_STATUS_REJECTED 0x100 - #define PPP_UNSPECIFIED 0xFFFF //// Type @@ -301,8 +294,6 @@ struct PPP_SESSION UCHAR ClientInterfaceId[8]; // Client IPv6CP Interface Identifier UINT PPPStatus; - UINT IPv4_State; - UINT IPv6_State; // EAP contexts UINT Eap_Protocol; // Current EAP Protocol used @@ -344,12 +335,14 @@ bool PPPProcessLCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req bool PPPProcessCHAPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req); bool PPPProcessIPCPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req); bool PPPProcessEAPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req); +bool PPPProcessIPv6CPResponsePacket(PPP_SESSION *p, PPP_PACKET *pp, PPP_PACKET *req); // Request packets bool PPPProcessRequestPacket(PPP_SESSION *p, PPP_PACKET *pp); bool PPPProcessLCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp); bool PPPProcessPAPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp); bool PPPProcessIPCPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp); bool PPPProcessEAPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp); +bool PPPProcessIPv6CPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp); // LCP option based packets utility bool PPPRejectLCPOptions(PPP_SESSION *p, PPP_PACKET *pp); @@ -369,7 +362,7 @@ PPP_PACKET *PPPRecvPacket(PPP_SESSION *p, bool async); // Helpers for delaying packets PPP_PACKET *PPPGetNextPacket(PPP_SESSION *p); void PPPAddNextPacket(PPP_SESSION *p, PPP_PACKET *pp, UINT delay); -int PPPDelayedPacketsComparator(const void *a, const void *b); +int PPPDelayedPacketsComparator(void *a, void *b); char PPPRelatedPacketComparator(PPP_PACKET *a, PPP_PACKET *b); // PPP utility functions diff --git a/src/Cedar/Virtual.c b/src/Cedar/Virtual.c index 26a27922..d5c88d47 100644 --- a/src/Cedar/Virtual.c +++ b/src/Cedar/Virtual.c @@ -98,7 +98,7 @@ NATIVE_NAT_ENTRY *NnGetOldestNatEntryOfIp(NATIVE_NAT *t, UINT ip, UINT protocol) return NULL; } - for (i = 0;i < LIST_NUM(t->NatTableForRecv->AllList);i++) + for (i = 0; i < LIST_NUM(t->NatTableForRecv->AllList); i++) { NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForRecv->AllList, i); @@ -129,7 +129,7 @@ UINT NnGetNumNatEntriesPerIp(NATIVE_NAT *t, UINT src_ip, UINT protocol) return 0; } - for (i = 0;i < LIST_NUM(t->NatTableForRecv->AllList);i++) + for (i = 0; i < LIST_NUM(t->NatTableForRecv->AllList); i++) { NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForRecv->AllList, i); @@ -160,7 +160,7 @@ void NnDeleteOldSessions(NATIVE_NAT *t) o = NULL; now = t->v->Now; - for (i = 0;i < LIST_NUM(t->NatTableForSend->AllList);i++) + for (i = 0; i < LIST_NUM(t->NatTableForSend->AllList); i++) { NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForSend->AllList, i); UINT64 timeout; @@ -188,7 +188,7 @@ void NnDeleteOldSessions(NATIVE_NAT *t) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { NATIVE_NAT_ENTRY *e = LIST_DATA(o, i); @@ -213,7 +213,7 @@ void NnDeleteSession(NATIVE_NAT *t, NATIVE_NAT_ENTRY *e) case NAT_TCP: // Send a RST to the client side SendTcp(t->v, e->DestIp, e->DestPort, e->SrcIp, e->SrcPort, - e->LastAck, e->LastSeq + (e->Status == NAT_TCP_CONNECTING ? 1 : 0), TCP_RST | TCP_ACK, 0, 0, NULL, 0); + e->LastAck, e->LastSeq + (e->Status == NAT_TCP_CONNECTING ? 1 : 0), TCP_RST | TCP_ACK, 0, 0, NULL, 0); NLog(t->v, "LH_NAT_TCP_DELETED", e->Id); break; @@ -246,7 +246,7 @@ void NnPollingIpCombine(NATIVE_NAT *t) // Discard the old combining object o = NULL; - for (i = 0;i < LIST_NUM(t->IpCombine);i++) + for (i = 0; i < LIST_NUM(t->IpCombine); i++) { IP_COMBINE *c = LIST_DATA(t->IpCombine, i); @@ -262,7 +262,7 @@ void NnPollingIpCombine(NATIVE_NAT *t) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP_COMBINE *c = LIST_DATA(o, i); @@ -336,7 +336,7 @@ void NnCombineIp(NATIVE_NAT *t, IP_COMBINE *c, UINT offset, void *data, UINT siz // Check the overlap between the region which is represented by the offset and size of the // existing received list and the region which is represented by the offset and size - for (i = 0;i < LIST_NUM(c->IpParts);i++) + for (i = 0; i < LIST_NUM(c->IpParts); i++) { UINT moving_size; IP_PART *p = LIST_DATA(c->IpParts, i); @@ -393,7 +393,7 @@ void NnCombineIp(NATIVE_NAT *t, IP_COMBINE *c, UINT offset, void *data, UINT siz UINT total_size = 0; UINT i; - for (i = 0;i < LIST_NUM(c->IpParts);i++) + for (i = 0; i < LIST_NUM(c->IpParts); i++) { IP_PART *p = LIST_DATA(c->IpParts, i); @@ -405,7 +405,7 @@ void NnCombineIp(NATIVE_NAT *t, IP_COMBINE *c, UINT offset, void *data, UINT siz // Received whole of the IP packet //Debug("Combine: %u\n", total_size); NnIpReceived(t, c->SrcIP, c->DestIP, c->Protocol, c->Data, c->Size, c->Ttl, - c->HeadIpHeaderData, c->HeadIpHeaderDataSize, c->MaxL3Size); + c->HeadIpHeaderData, c->HeadIpHeaderDataSize, c->MaxL3Size); // Release the combining object NnFreeIpCombine(t, c); @@ -431,7 +431,7 @@ void NnFreeIpCombine(NATIVE_NAT *t, IP_COMBINE *c) Free(c->Data); // Release the partial list - for (i = 0;i < LIST_NUM(c->IpParts);i++) + for (i = 0; i < LIST_NUM(c->IpParts); i++) { IP_PART *p = LIST_DATA(c->IpParts, i); @@ -525,7 +525,7 @@ void NnFreeIpCombineList(NATIVE_NAT *t) return; } - for (i = 0;i < LIST_NUM(t->IpCombine);i++) + for (i = 0; i < LIST_NUM(t->IpCombine); i++) { IP_COMBINE *c = LIST_DATA(t->IpCombine, i); @@ -707,7 +707,7 @@ void NnIcmpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, void *data, UINT s ret_echo->SeqNo = echo->SeqNo; Copy((UCHAR *)ret_icmp + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO), - payload, payload_size); + payload, payload_size); ret_icmp->Checksum = IpChecksum(ret_icmp, ret_size); @@ -738,7 +738,7 @@ void NnIcmpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, void *data, UINT s if (inner_icmp_size >= (sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO))) { ICMP_HEADER *inner_icmp = (ICMP_HEADER *)(((UCHAR *)data) + - sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + orig_ipv4_header_size); + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + orig_ipv4_header_size); if (inner_icmp->Type == ICMP_TYPE_ECHO_REQUEST) { @@ -850,14 +850,14 @@ void NnUdpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, void *data, UINT si // Deliver to the client by rewriting the port number SendUdp(t->v, e->SrcIp, e->SrcPort, src_ip, Endian16(udp->SrcPort), - payload, payload_size); + payload, payload_size); } } } // A combined IP packet is received void NnIpReceived(NATIVE_NAT *t, UINT src_ip, UINT dest_ip, UINT protocol, void *data, UINT size, - UCHAR ttl, UCHAR *ip_header, UINT ip_header_size, UINT max_l3_size) + UCHAR ttl, UCHAR *ip_header, UINT ip_header_size, UINT max_l3_size) { // Validate arguments if (t == NULL || data == NULL) @@ -939,7 +939,7 @@ void NnFragmentedIpReceived(NATIVE_NAT *t, PKT *packet) // Because this packet has not been fragmented, it can be passed to the upper layer immediately head_ip_header_data = (UCHAR *)packet->L3.IPv4Header; NnIpReceived(t, ip->SrcIP, ip->DstIP, ip->Protocol, data, size, ip->TimeToLive, - head_ip_header_data, head_ip_header_size, l3_size); + head_ip_header_data, head_ip_header_size, l3_size); } else { @@ -964,8 +964,8 @@ void NnFragmentedIpReceived(NATIVE_NAT *t, PKT *packet) { // Create a combining object because it is the first packet c = NnInsertIpCombine( - t, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol, packet->BroadcastPacket, - ip->TimeToLive, false); + t, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol, packet->BroadcastPacket, + ip->TimeToLive, false); if (c != NULL) { c->MaxL3Size = MAX(c->MaxL3Size, l3_size); @@ -1050,7 +1050,7 @@ void NnPoll(NATIVE_NAT *t) // Send a fragmented IP packet to the Internet void NnIpSendFragmentedForInternet(NATIVE_NAT *t, UCHAR ip_protocol, UINT src_ip, UINT dest_ip, USHORT id, USHORT total_size, - USHORT offset, void *data, UINT size, UCHAR ttl) + USHORT offset, void *data, UINT size, UCHAR ttl) { UCHAR *buf; IPV4_HEADER *ip; @@ -1165,7 +1165,7 @@ void NnIpSendForInternet(NATIVE_NAT *t, UCHAR ip_protocol, UCHAR ttl, UINT src_i // Transmit the fragmented packet NnIpSendFragmentedForInternet(t, ip_protocol, src_ip, dest_ip, id, total_size, offset, - buf + offset, size_of_this_packet, ttl); + buf + offset, size_of_this_packet, ttl); if (last_packet) { break; @@ -1211,7 +1211,7 @@ void NnIcmpEchoRecvForInternet(VH *v, UINT src_ip, UINT dest_ip, void *data, UIN { // Respond because it is addressed to me VirtualIcmpEchoSendResponse(v, dest_ip, src_ip, Endian16(old_icmp_echo->Identifier), - Endian16(old_icmp_echo->SeqNo), payload_data, payload_size); + Endian16(old_icmp_echo->SeqNo), payload_data, payload_size); return; } @@ -1562,7 +1562,7 @@ UINT NnMapNewPublicPort(NATIVE_NAT *t, UINT protocol, UINT dest_ip, UINT dest_po base_port = Rand32() % (port_end - port_start) + port_start; - for (i = 0;i < (port_end - port_start);i++) + for (i = 0; i < (port_end - port_start); i++) { UINT port; NATIVE_NAT_ENTRY tt; @@ -1706,8 +1706,8 @@ LABEL_RESTART: // Start a connectivity check periodically dns_query = NnBuildIpPacket(NnBuildUdpPacket(NnBuildDnsQueryPacket(NN_CHECK_HOSTNAME, dns_tran_id), - IPToUINT(&ipc->ClientIPAddress), dns_src_port, IPToUINT(&a->DnsServerIP), 53), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP), IP_PROTO_UDP, 0); + IPToUINT(&ipc->ClientIPAddress), dns_src_port, IPToUINT(&a->DnsServerIP), 53), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP), IP_PROTO_UDP, 0); IPCSendIPv4(ipc, dns_query->Buf, dns_query->Size); @@ -1753,7 +1753,7 @@ LABEL_RESTART: UnlockQueue(t->SendQueue); // Happy processing - IPCProcessL3Events(ipc); + IPCProcessL3EventsIPv4Only(ipc); LockQueue(t->RecvQueue); { @@ -1782,9 +1782,9 @@ LABEL_RESTART: if (wait_for_dns) { if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_UDP && - pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP) && - pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && - pkt->L4.UDPHeader->SrcPort == Endian16(53) && pkt->L4.UDPHeader->DstPort == Endian16(dns_src_port)) + pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP) && + pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && + pkt->L4.UDPHeader->SrcPort == Endian16(53) && pkt->L4.UDPHeader->DstPort == Endian16(dns_src_port)) { DNSV4_HEADER *dns_header = (DNSV4_HEADER *)pkt->Payload; if (pkt->PayloadSize >= sizeof(DNSV4_HEADER)) @@ -1809,8 +1809,8 @@ LABEL_RESTART: // Generate a TCP connection attempt packet tcp_seq = Rand32(); tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), tcp_src_port, - IPToUINT(&yahoo_ip), 80, tcp_seq, 0, TCP_SYN, 8192, 1414), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); + IPToUINT(&yahoo_ip), 80, tcp_seq, 0, TCP_SYN, 8192, 1414), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size); @@ -1824,9 +1824,9 @@ LABEL_RESTART: } if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_TCP && - pkt->L3.IPv4Header->SrcIP == IPToUINT(&yahoo_ip) && - pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && - pkt->L4.TCPHeader->SrcPort == Endian16(80) && pkt->L4.TCPHeader->DstPort == Endian16(tcp_src_port)) + pkt->L3.IPv4Header->SrcIP == IPToUINT(&yahoo_ip) && + pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && + pkt->L4.TCPHeader->SrcPort == Endian16(80) && pkt->L4.TCPHeader->DstPort == Endian16(tcp_src_port)) { TCP_HEADER *tcp_header = (TCP_HEADER *)pkt->L4.TCPHeader; if ((tcp_header->Flag & TCP_SYN) && (tcp_header->Flag & TCP_ACK)) @@ -1839,8 +1839,8 @@ LABEL_RESTART: // Send a RST tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), tcp_src_port, - IPToUINT(&yahoo_ip), 80, tcp_seq + 1, recv_seq, TCP_RST | TCP_ACK, 8192, 0), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); + IPToUINT(&yahoo_ip), 80, tcp_seq + 1, recv_seq, TCP_RST | TCP_ACK, 8192, 0), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size); @@ -2220,7 +2220,7 @@ bool NnParseDnsResponsePacket(UCHAR *data, UINT size, IP *ret_ip) UINT num_answers = Endian16(h.AnswerRRs); UINT i; - for (i = 0;i < num_questions;i++) + for (i = 0; i < num_questions; i++) { BUF *r = NnReadDnsRecord(buf, false, NULL, NULL); @@ -2234,7 +2234,7 @@ bool NnParseDnsResponsePacket(UCHAR *data, UINT size, IP *ret_ip) } } - for (i = 0;i < num_answers;i++) + for (i = 0; i < num_answers; i++) { USHORT tp, cl; BUF *r = NnReadDnsRecord(buf, true, &tp, &cl); @@ -2330,12 +2330,12 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) // Try to get an IP address of www.yahoo.com dns_query = NnBuildIpPacket(NnBuildUdpPacket(NnBuildDnsQueryPacket(NN_CHECK_HOSTNAME, dns_tran_id), - IPToUINT(&ipc->ClientIPAddress), src_port, IPToUINT(&a->DnsServerIP), 53), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP), IP_PROTO_UDP, 0); + IPToUINT(&ipc->ClientIPAddress), src_port, IPToUINT(&a->DnsServerIP), 53), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP), IP_PROTO_UDP, 0); dns_query2 = NnBuildIpPacket(NnBuildUdpPacket(NnBuildDnsQueryPacket(NN_CHECK_HOSTNAME, dns_tran_id), - IPToUINT(&ipc->ClientIPAddress), src_port, IPToUINT(&a->DnsServerIP), 53), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP2), IP_PROTO_UDP, 0); + IPToUINT(&ipc->ClientIPAddress), src_port, IPToUINT(&a->DnsServerIP), 53), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&a->DnsServerIP2), IP_PROTO_UDP, 0); giveup_time = Tick64() + NN_CHECK_CONNECTIVITY_TIMEOUT; AddInterrupt(interrupt, giveup_time); @@ -2370,7 +2370,7 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) } // Happy processing - IPCProcessL3Events(ipc); + IPCProcessL3EventsIPv4Only(ipc); while (true) { @@ -2389,10 +2389,10 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) if (pkt != NULL) { if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_UDP && - (pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP) || - pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP2)) && - pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && - pkt->L4.UDPHeader->SrcPort == Endian16(53) && pkt->L4.UDPHeader->DstPort == Endian16(src_port)) + (pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP) || + pkt->L3.IPv4Header->SrcIP == IPToUINT(&a->DnsServerIP2)) && + pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && + pkt->L4.UDPHeader->SrcPort == Endian16(53) && pkt->L4.UDPHeader->DstPort == Endian16(src_port)) { DNSV4_HEADER *dns_header = (DNSV4_HEADER *)pkt->Payload; if (pkt->PayloadSize >= sizeof(DNSV4_HEADER)) @@ -2418,7 +2418,7 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) } if ((halt_tube != NULL && IsTubeConnected(halt_tube) == false) || - IsTubeConnected(ipc->Sock->SendTube) == false || IsTubeConnected(ipc->Sock->RecvTube) == false) + IsTubeConnected(ipc->Sock->SendTube) == false || IsTubeConnected(ipc->Sock->RecvTube) == false) { // Disconnected break; @@ -2450,8 +2450,8 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) // Generate a TCP packet tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), src_port, - IPToUINT(&yahoo_ip), 80, seq, 0, TCP_SYN, 8192, 1414), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); + IPToUINT(&yahoo_ip), 80, seq, 0, TCP_SYN, 8192, 1414), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); Debug("Test TCP to %r\n", &yahoo_ip); @@ -2479,7 +2479,7 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) } // Happy procedure - IPCProcessL3Events(ipc); + IPCProcessL3EventsIPv4Only(ipc); while (true) { @@ -2498,9 +2498,9 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) if (pkt != NULL) { if (pkt->TypeL3 == L3_IPV4 && pkt->TypeL4 == L4_TCP && - pkt->L3.IPv4Header->SrcIP == IPToUINT(&yahoo_ip) && - pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && - pkt->L4.TCPHeader->SrcPort == Endian16(80) && pkt->L4.TCPHeader->DstPort == Endian16(src_port)) + pkt->L3.IPv4Header->SrcIP == IPToUINT(&yahoo_ip) && + pkt->L3.IPv4Header->DstIP == IPToUINT(&ipc->ClientIPAddress) && + pkt->L4.TCPHeader->SrcPort == Endian16(80) && pkt->L4.TCPHeader->DstPort == Endian16(src_port)) { TCP_HEADER *tcp_header = (TCP_HEADER *)pkt->L4.TCPHeader; if ((tcp_header->Flag & TCP_SYN) && (tcp_header->Flag & TCP_ACK)) @@ -2517,7 +2517,7 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) } if ((halt_tube != NULL && IsTubeConnected(halt_tube) == false) || - IsTubeConnected(ipc->Sock->SendTube) == false || IsTubeConnected(ipc->Sock->RecvTube) == false) + IsTubeConnected(ipc->Sock->SendTube) == false || IsTubeConnected(ipc->Sock->RecvTube) == false) { // Disconnected break; @@ -2542,8 +2542,8 @@ bool NnTestConnectivity(NATIVE_STACK *a, TUBE *halt_tube) } tcp_query = NnBuildIpPacket(NnBuildTcpPacket(NewBuf(), IPToUINT(&ipc->ClientIPAddress), src_port, - IPToUINT(&yahoo_ip), 80, seq + 1, recv_seq, TCP_RST | TCP_ACK, 8192, 0), - IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); + IPToUINT(&yahoo_ip), 80, seq + 1, recv_seq, TCP_RST | TCP_ACK, 8192, 0), + IPToUINT(&ipc->ClientIPAddress), IPToUINT(&yahoo_ip), IP_PROTO_TCP, 0); IPCSendIPv4(ipc, tcp_query->Buf, tcp_query->Size); @@ -2612,8 +2612,8 @@ NATIVE_STACK *NnGetNextInterface(NATIVE_NAT *t) // Get the device list device_list = GetEthListEx(NULL, - !(t->v->HubOption != NULL && t->v->HubOption->DisableKernelModeSecureNAT), - !(t->v->HubOption != NULL && t->v->HubOption->DisableIpRawModeSecureNAT)); + !(t->v->HubOption != NULL && t->v->HubOption->DisableKernelModeSecureNAT), + !(t->v->HubOption != NULL && t->v->HubOption->DisableIpRawModeSecureNAT)); if (device_list == NULL || device_list->NumTokens == 0) { @@ -2703,7 +2703,7 @@ NATIVE_STACK *NnGetNextInterface(NATIVE_NAT *t) IPToStr32(gateway_ip, sizeof(gateway_ip), opt.Gateway); Debug("DHCP: client_ip=%s, client_mask=%s, dhcp_ip=%s, gateway_ip=%s\n", - client_ip, client_mask, dhcp_ip, gateway_ip); + client_ip, client_mask, dhcp_ip, gateway_ip); Copy(&ret->CurrentDhcpOptionList, &opt, sizeof(DHCP_OPTION_LIST)); @@ -2731,7 +2731,7 @@ NATIVE_STACK *NnGetNextInterface(NATIVE_NAT *t) // Connectivity test // (always fail if the default gateway is not set) if (opt.Gateway != 0 && - NnTestConnectivity(ret, t->HaltTube2)) + NnTestConnectivity(ret, t->HaltTube2)) { // Reset the number of search failures t->FailedCount = 0; @@ -2783,7 +2783,7 @@ void NativeNatThread(THREAD *thread, void *param) } // If the NAT is disabled, wait until it becomes enabled - Wait(t->HaltEvent, 1234); + Wait(t->HaltEvent, 1234); } if (t->Halt) @@ -2829,8 +2829,8 @@ void NativeNatThread(THREAD *thread, void *param) Debug("NnMainLoop Start.\n"); MacToStr(macstr, sizeof(macstr), a->Ipc->MacAddress); NLog(t->v, "LH_KERNEL_MODE_START", a->DeviceName, - &a->Ipc->ClientIPAddress, &a->Ipc->SubnetMask, &a->Ipc->DefaultGateway, &a->Ipc->BroadcastAddress, - macstr, &a->CurrentDhcpOptionList.ServerAddress, &a->DnsServerIP); + &a->Ipc->ClientIPAddress, &a->Ipc->SubnetMask, &a->Ipc->DefaultGateway, &a->Ipc->BroadcastAddress, + macstr, &a->CurrentDhcpOptionList.ServerAddress, &a->DnsServerIP); NnMainLoop(t, a); Debug("NnMainLoop End.\n"); @@ -3203,7 +3203,7 @@ void FreeNativeNat(NATIVE_NAT *t) ReleaseCancel(t->Cancel); // Release the NAT table - for (i = 0;i < LIST_NUM(t->NatTableForSend->AllList);i++) + for (i = 0; i < LIST_NUM(t->NatTableForSend->AllList); i++) { NATIVE_NAT_ENTRY *e = LIST_DATA(t->NatTableForSend->AllList, i); @@ -3254,7 +3254,7 @@ NAT_ENTRY *GetOldestNatEntryOfIp(VH *v, UINT ip, UINT protocol) return NULL; } - for (i = 0;i < LIST_NUM(v->NatTable);i++) + for (i = 0; i < LIST_NUM(v->NatTable); i++) { NAT_ENTRY *e = LIST_DATA(v->NatTable, i); @@ -3291,7 +3291,7 @@ UINT GetNumNatEntriesPerIp(VH *v, UINT ip, UINT protocol, bool tcp_syn_sent) return 0; } - for (i = 0;i < LIST_NUM(v->NatTable);i++) + for (i = 0; i < LIST_NUM(v->NatTable); i++) { NAT_ENTRY *e = LIST_DATA(v->NatTable, i); @@ -3425,7 +3425,7 @@ void NatThreadMain(VH *v) LIST_ELEMENT_DELETED: num = LIST_NUM(v->NatTable); - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { NAT_ENTRY *n = LIST_DATA(v->NatTable, i); @@ -3484,7 +3484,7 @@ LIST_ELEMENT_DELETED: NAT_ENTRY **nn = ToArray(v->NatTable); UINT i; - for (i = 0;i < num;i++) + for (i = 0; i < num; i++) { NAT_ENTRY *n = nn[i]; n->DisconnectNow = true; @@ -3695,7 +3695,7 @@ bool ArpaToIP(IP *ip, char *str) // Convert the token [0, 1, 2, 3] to IP UINT i; Zero(ip, sizeof(IP)); - for (i = 0;i < 4;i++) + for (i = 0; i < 4; i++) { ip->addr[i] = (UCHAR)ToInt(token->Token[3 - i]); } @@ -3815,7 +3815,7 @@ void NatIcmpThreadProc(THREAD *thread, void *param) // Send a query by using the ICMP API ret = IcmpApiEchoSend(&dest_ip, n->IcmpQueryBlock->Ttl, - icmp_payload, icmp_payload_size, NAT_ICMP_TIMEOUT_WITH_API); + icmp_payload, icmp_payload_size, NAT_ICMP_TIMEOUT_WITH_API); } } } @@ -4015,7 +4015,7 @@ bool NatTransactIcmp(VH *v, NAT_ENTRY *n) if (ret != NULL) { if ((ret->Ok && CmpIpAddr(&ret->IpAddress, &dest_ip) == 0) || - (ret->DataSize >= sizeof(IPV4_HEADER) && ((IPV4_HEADER *)ret->Data)->DstIP == n->DestIp)) + (ret->DataSize >= sizeof(IPV4_HEADER) && ((IPV4_HEADER *)ret->Data)->DstIP == n->DestIp)) { // Insert to the queue void *data = Malloc(recv_size); @@ -4203,7 +4203,7 @@ bool NatTransactUdp(VH *v, NAT_ENTRY *n) UINT send_size; bool is_nbtdgm = false; LIST *local_ip_list = NULL; - + if (dest_port == SPECIAL_UDP_PORT_NBTDGM) { // Determine whether NetBIOS Datagram packet @@ -4234,7 +4234,7 @@ bool NatTransactUdp(VH *v, NAT_ENTRY *n) // Transfer by rewriting it properly UINT i; - for (i = 0;i < LIST_NUM(local_ip_list);i++) + for (i = 0; i < LIST_NUM(local_ip_list); i++) { IP *my_ip = LIST_DATA(local_ip_list, i); @@ -4417,108 +4417,108 @@ bool NatTransactTcp(VH *v, NAT_ENTRY *n) break; case NAT_TCP_ESTABLISHED: // TCP connection established + { + UINT old_send_fifo_size = 0; + + // Transmit to the socket if there is data in the receive buffer + while (n->RecvFifo->size > 0) { - UINT old_send_fifo_size = 0; - - // Transmit to the socket if there is data in the receive buffer - while (n->RecvFifo->size > 0) + UINT sent_size = Send(n->Sock, ((UCHAR *)n->RecvFifo->p) + n->RecvFifo->pos, + n->RecvFifo->size, false); + if (sent_size == 0) { - UINT sent_size = Send(n->Sock, ((UCHAR *)n->RecvFifo->p) + n->RecvFifo->pos, - n->RecvFifo->size, false); - if (sent_size == 0) - { - // Communication has been disconnected - n->TcpFinished = true; - v->NatDoCancelFlag = true; - break; - } - else if (sent_size == SOCK_LATER) - { - // Blocking - break; - } - else - { - // Successful transmission - ReadFifo(n->RecvFifo, NULL, sent_size); - n->SendAckNext = true; - - if (false) - { - IP ip; - - n->test_TotalSent += sent_size; - - UINTToIP(&ip, n->DestIp); - Debug("TCP %u: %r:%u %u\n", n->Id, &ip, n->DestPort, (UINT)n->test_TotalSent); - } - } + // Communication has been disconnected + n->TcpFinished = true; + v->NatDoCancelFlag = true; + break; } - - old_send_fifo_size = FifoSize(n->SendFifo); - - // Write to the transmission buffer by obtaining data from the socket - while (true) + else if (sent_size == SOCK_LATER) { - void *buf = (void *)v->TmpBuf; - UINT want_to_recv_size = 0; - UINT recv_size; - // Calculate the size of wanting to receive - if (n->SendFifo->size < NAT_SEND_BUF_SIZE) - { - // Still can receive - want_to_recv_size = MIN(NAT_SEND_BUF_SIZE - n->SendFifo->size, NAT_TMPBUF_SIZE); - } - if (want_to_recv_size == 0) - { - SetNoNeedToRead(n->Sock); - break; - } - recv_size = Recv(n->Sock, buf, want_to_recv_size, false); - if (recv_size == 0) - { - // Communication has been disconnected - n->TcpFinished = true; - v->NatDoCancelFlag = true; - if (n->TcpDisconnected == false) - { - Disconnect(n->Sock); - n->TcpDisconnected = true; - } - break; - } - else if (recv_size == SOCK_LATER) - { - // Blocking - break; - } - else - { - // Successful reception - WriteFifo(n->SendFifo, buf, recv_size); - v->NatDoCancelFlag = true; - } + // Blocking + break; } - - if (old_send_fifo_size == 0 && FifoSize(n->SendFifo) != 0) + else { - // Reset the time data for timeout when the data is newly queued - // in the empty transmission buffer in the transmission process - n->TcpLastRecvAckTime = v->Now; - } + // Successful transmission + ReadFifo(n->RecvFifo, NULL, sent_size); + n->SendAckNext = true; - // Raise a transmission time-out if a certain period of time elapsed - // after receiving the last ACK, and the transmission buffer is not - // empty, and the reception window size of other party is not 0 - if ((n->TcpLastRecvAckTime + (UINT64)VIRTUAL_TCP_SEND_TIMEOUT) < v->Now) - { - if (FifoSize(n->SendFifo) != 0 && n->TcpSendWindowSize != 0) + if (false) { - timeouted = true; + IP ip; + + n->test_TotalSent += sent_size; + + UINTToIP(&ip, n->DestIp); + Debug("TCP %u: %r:%u %u\n", n->Id, &ip, n->DestPort, (UINT)n->test_TotalSent); } } } - break; + + old_send_fifo_size = FifoSize(n->SendFifo); + + // Write to the transmission buffer by obtaining data from the socket + while (true) + { + void *buf = (void *)v->TmpBuf; + UINT want_to_recv_size = 0; + UINT recv_size; + // Calculate the size of wanting to receive + if (n->SendFifo->size < NAT_SEND_BUF_SIZE) + { + // Still can receive + want_to_recv_size = MIN(NAT_SEND_BUF_SIZE - n->SendFifo->size, NAT_TMPBUF_SIZE); + } + if (want_to_recv_size == 0) + { + SetNoNeedToRead(n->Sock); + break; + } + recv_size = Recv(n->Sock, buf, want_to_recv_size, false); + if (recv_size == 0) + { + // Communication has been disconnected + n->TcpFinished = true; + v->NatDoCancelFlag = true; + if (n->TcpDisconnected == false) + { + Disconnect(n->Sock); + n->TcpDisconnected = true; + } + break; + } + else if (recv_size == SOCK_LATER) + { + // Blocking + break; + } + else + { + // Successful reception + WriteFifo(n->SendFifo, buf, recv_size); + v->NatDoCancelFlag = true; + } + } + + if (old_send_fifo_size == 0 && FifoSize(n->SendFifo) != 0) + { + // Reset the time data for timeout when the data is newly queued + // in the empty transmission buffer in the transmission process + n->TcpLastRecvAckTime = v->Now; + } + + // Raise a transmission time-out if a certain period of time elapsed + // after receiving the last ACK, and the transmission buffer is not + // empty, and the reception window size of other party is not 0 + if ((n->TcpLastRecvAckTime + (UINT64)VIRTUAL_TCP_SEND_TIMEOUT) < v->Now) + { + if (FifoSize(n->SendFifo) != 0 && n->TcpSendWindowSize != 0) + { + timeouted = true; + } + } + } + break; } @@ -4582,7 +4582,7 @@ void DeleteNatTcp(VH *v, NAT_ENTRY *n) if (n->TcpRecvList != NULL) { UINT i; - for (i = 0;i < LIST_NUM(n->TcpRecvList);i++) + for (i = 0; i < LIST_NUM(n->TcpRecvList); i++) { IP_PART *p = LIST_DATA(n->TcpRecvList, i); Free(p); @@ -4627,7 +4627,7 @@ void SendBeacon(VH *v) UINT dest_ip; ARPV4_HEADER arp; static char beacon_str[] = - "SecureNAT Virtual TCP/IP Stack Beacon"; + "SecureNAT Virtual TCP/IP Stack Beacon"; // Validate arguments if (v == NULL) { @@ -4647,11 +4647,11 @@ void SendBeacon(VH *v) Copy(arp.SrcAddress, v->MacAddress, 6); arp.SrcIP = v->HostIP; arp.TargetAddress[0] = - arp.TargetAddress[1] = - arp.TargetAddress[2] = - arp.TargetAddress[3] = - arp.TargetAddress[4] = - arp.TargetAddress[5] = 0xff; + arp.TargetAddress[1] = + arp.TargetAddress[2] = + arp.TargetAddress[3] = + arp.TargetAddress[4] = + arp.TargetAddress[5] = 0xff; arp.TargetIP = dest_ip; // Transmission @@ -4750,10 +4750,10 @@ void PollingNatTcp(VH *v, NAT_ENTRY *n) n->LastSynAckSentTime = v->Now; // Send a SYN + ACK SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeqInit + n->SendSeq), - (UINT)(n->RecvSeqInit + n->RecvSeq), - TCP_SYN | TCP_ACK, n->TcpRecvWindowSize, - v->TcpMss, NULL, 0); + (UINT)(n->SendSeqInit + n->SendSeq), + (UINT)(n->RecvSeqInit + n->RecvSeq), + TCP_SYN | TCP_ACK, n->TcpRecvWindowSize, + v->TcpMss, NULL, 0); n->SynAckSentCount++; } break; @@ -4763,10 +4763,10 @@ void PollingNatTcp(VH *v, NAT_ENTRY *n) if (n->TcpFinished == false || n->TcpForceReset) { SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeq + n->SendSeqInit), - (UINT)(n->SendSeq + n->SendSeqInit), - TCP_RST, 0, - 0, NULL, 0); + (UINT)(n->SendSeq + n->SendSeqInit), + (UINT)(n->SendSeq + n->SendSeqInit), + TCP_RST, 0, + 0, NULL, 0); // Disconnect n->TcpStatus = NAT_TCP_WAIT_DISCONNECT; n->DisconnectNow = true; @@ -4777,10 +4777,10 @@ void PollingNatTcp(VH *v, NAT_ENTRY *n) if (n->FinSentTime == 0 || (n->FinSentTime > v->Now) || (n->FinSentTime + NAT_FIN_SEND_INTERVAL * (n->FinSentCount + 1)) < v->Now) { SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeq + n->SendSeqInit), - (UINT)(n->RecvSeq + n->RecvSeqInit), - TCP_ACK | TCP_FIN, 0, - 0, NULL, 0); + (UINT)(n->SendSeq + n->SendSeqInit), + (UINT)(n->RecvSeq + n->RecvSeqInit), + TCP_ACK | TCP_FIN, 0, + 0, NULL, 0); n->FinSentTime = v->Now; n->FinSentSeq = (UINT)(n->SendSeq + n->SendSeqInit); n->FinSentCount++; @@ -4793,120 +4793,120 @@ void PollingNatTcp(VH *v, NAT_ENTRY *n) break; case NAT_TCP_ESTABLISHED: // Connection established + { + UINT send_data_size; + UINT current_pointer; + UINT notice_window_size_value = 0; + UINT buf_free_bytes = 0; + // Determine the value of the window size to be notified + if (FifoSize(n->RecvFifo) < NAT_RECV_BUF_SIZE) { - UINT send_data_size; - UINT current_pointer; - UINT notice_window_size_value = 0; - UINT buf_free_bytes = 0; - // Determine the value of the window size to be notified - if (FifoSize(n->RecvFifo) < NAT_RECV_BUF_SIZE) + buf_free_bytes = NAT_RECV_BUF_SIZE - FifoSize(n->RecvFifo); + } + notice_window_size_value = MIN(n->TcpRecvWindowSize, buf_free_bytes); + if (n->LastSentKeepAliveTime == 0 || + (n->LastSentKeepAliveTime + (UINT64)NAT_ACK_KEEPALIVE_SPAN) < v->Now || + (n->LastSentKeepAliveTime > v->Now)) + { + if (n->LastSentKeepAliveTime != 0) { - buf_free_bytes = NAT_RECV_BUF_SIZE - FifoSize(n->RecvFifo); + // Send an ACK packet for Keep-Alive + SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, + (UINT)(n->SendSeqInit + n->SendSeq), + (UINT)(n->RecvSeqInit + n->RecvSeq) - 1, + TCP_ACK, + notice_window_size_value, + 0, + NULL, + 0); } - notice_window_size_value = MIN(n->TcpRecvWindowSize, buf_free_bytes); - if (n->LastSentKeepAliveTime == 0 || - (n->LastSentKeepAliveTime + (UINT64)NAT_ACK_KEEPALIVE_SPAN) < v->Now || - (n->LastSentKeepAliveTime > v->Now)) + n->LastSentKeepAliveTime = v->Now; + } + if (n->TcpLastSentTime == 0 || + (n->TcpLastSentTime > v->Now) || + ((n->TcpLastSentTime + (UINT64)n->TcpSendTimeoutSpan) < v->Now) || + n->SendAckNext) + { + // If there is data to send, send the data + // Calculate the segment size to be transmitted + send_data_size = n->TcpSendWindowSize; + if (send_data_size > (n->TcpSendCWnd * n->TcpSendMaxSegmentSize)) { - if (n->LastSentKeepAliveTime != 0) + // Apply the cwnd value + send_data_size = n->TcpSendCWnd * n->TcpSendMaxSegmentSize; + } + if (send_data_size > n->SendFifo->size) + { + // Can not be sent over the data that is currently held + send_data_size = n->SendFifo->size; + } + if (send_data_size >= 1) + { + // Transmit the fragmented segments + current_pointer = 0; + while (send_data_size > 0) { - // Send an ACK packet for Keep-Alive + UINT send_segment_size = MIN(n->TcpSendMaxSegmentSize, send_data_size); + void *send_segment = (void *)(((UCHAR *)n->SendFifo->p) + n->SendFifo->pos + current_pointer); SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeqInit + n->SendSeq), - (UINT)(n->RecvSeqInit + n->RecvSeq) - 1, - TCP_ACK, - notice_window_size_value, - 0, - NULL, - 0); + (UINT)(n->SendSeqInit + n->SendSeq + (UINT64)current_pointer), + (UINT)(n->RecvSeqInit + n->RecvSeq), + TCP_ACK | TCP_PSH, + notice_window_size_value, + 0, + send_segment, + send_segment_size); + current_pointer += send_segment_size; + send_data_size -= send_segment_size; + } + // Record the transmission time + n->TcpLastSentTime = v->Now; + // Record the stream size to be transmitted this time + n->SendMissionSize = current_pointer; + n->CurrentSendingMission = true; + // RTT measurement + if (n->CalcRTTStartTime == 0) + { + n->CalcRTTStartTime = v->Now; + n->CalcRTTStartValue = n->SendSeq + current_pointer - 1; + } + if (n->RetransmissionUsedFlag == false) + { + n->RetransmissionUsedFlag = true; + } + else + { + // Congestion is detected + if (n->TcpSendCWnd > 2) + { + n->TcpSendCWnd--; + } } - n->LastSentKeepAliveTime = v->Now; } - if (n->TcpLastSentTime == 0 || - (n->TcpLastSentTime > v->Now) || - ((n->TcpLastSentTime + (UINT64)n->TcpSendTimeoutSpan) < v->Now) || - n->SendAckNext) + else if (n->SendAckNext) { - // If there is data to send, send the data - // Calculate the segment size to be transmitted - send_data_size = n->TcpSendWindowSize; - if (send_data_size > (n->TcpSendCWnd * n->TcpSendMaxSegmentSize)) - { - // Apply the cwnd value - send_data_size = n->TcpSendCWnd * n->TcpSendMaxSegmentSize; - } - if (send_data_size > n->SendFifo->size) - { - // Can not be sent over the data that is currently held - send_data_size = n->SendFifo->size; - } - if (send_data_size >= 1) - { - // Transmit the fragmented segments - current_pointer = 0; - while (send_data_size > 0) - { - UINT send_segment_size = MIN(n->TcpSendMaxSegmentSize, send_data_size); - void *send_segment = (void *)(((UCHAR *)n->SendFifo->p) + n->SendFifo->pos + current_pointer); - SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeqInit + n->SendSeq + (UINT64)current_pointer), - (UINT)(n->RecvSeqInit + n->RecvSeq), - TCP_ACK | TCP_PSH, - notice_window_size_value, - 0, - send_segment, - send_segment_size); - current_pointer += send_segment_size; - send_data_size -= send_segment_size; - } - // Record the transmission time - n->TcpLastSentTime = v->Now; - // Record the stream size to be transmitted this time - n->SendMissionSize = current_pointer; - n->CurrentSendingMission = true; - // RTT measurement - if (n->CalcRTTStartTime == 0) - { - n->CalcRTTStartTime = v->Now; - n->CalcRTTStartValue = n->SendSeq + current_pointer - 1; - } - if (n->RetransmissionUsedFlag == false) - { - n->RetransmissionUsedFlag = true; - } - else - { - // Congestion is detected - if (n->TcpSendCWnd > 2) - { - n->TcpSendCWnd--; - } - } - } - else if (n->SendAckNext) - { - // Send only an ACK - SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeqInit + n->SendSeq), - (UINT)(n->RecvSeqInit + n->RecvSeq), - TCP_ACK, - notice_window_size_value, - 0, - NULL, - 0); - } - n->SendAckNext = false; + // Send only an ACK + SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, + (UINT)(n->SendSeqInit + n->SendSeq), + (UINT)(n->RecvSeqInit + n->RecvSeq), + TCP_ACK, + notice_window_size_value, + 0, + NULL, + 0); } - if (n->TcpFinished) + n->SendAckNext = false; + } + if (n->TcpFinished) + { + // Disconnect if all data transmission has completed + if (n->SendFifo->size == 0 && n->RecvFifo->size == 0) { - // Disconnect if all data transmission has completed - if (n->SendFifo->size == 0 && n->RecvFifo->size == 0) - { - n->TcpStatus = NAT_TCP_SEND_RESET; - } + n->TcpStatus = NAT_TCP_SEND_RESET; } } - break; + } + break; } } @@ -4935,7 +4935,7 @@ void TcpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT de { // Disable User-mode NAT SendTcp(v, dest_ip, dest_port, src_ip, src_port, - 0, seq + 1, TCP_RST | TCP_ACK, 0, 0, NULL, 0); + 0, seq + 1, TCP_RST | TCP_ACK, 0, 0, NULL, 0); return; } @@ -4956,7 +4956,7 @@ void TcpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT de { // Return the RST if it was not possible to create SendTcp(v, dest_ip, dest_port, src_ip, src_port, - 0, seq + 1, TCP_RST | TCP_ACK, 0, 0, NULL, 0); + 0, seq + 1, TCP_RST | TCP_ACK, 0, 0, NULL, 0); return; } @@ -4991,7 +4991,7 @@ void TcpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT de { // Return a RST since a packet which is not registered in the NAT entry arrived SendTcp(v, dest_ip, dest_port, src_ip, src_port, - ack, ack, TCP_RST, 0, 0, NULL, 0); + ack, ack, TCP_RST, 0, 0, NULL, 0); return; } @@ -5016,7 +5016,7 @@ void TcpRecvForInternet(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT de if ((tcp->Flag & TCP_ACK) && ((tcp->Flag & TCP_SYN) == false)) { if (seq == (UINT)(n->RecvSeqInit + n->RecvSeq) && - ack == (UINT)(n->SendSeqInit + n->SendSeq + 1)) + ack == (UINT)(n->SendSeqInit + n->SendSeq + 1)) { // Handshake complete since the ACK packet came back n->SendSeq++; // SYN packet consumes the seq by 1 @@ -5105,11 +5105,11 @@ TCP_RESET: // Smoothing n->CurrentRTT = - (UINT) - ( - ((UINT64)n->CurrentRTT * (UINT64)9 + - (UINT64)time_span * (UINT64)1) / (UINT64)10 - ); + (UINT) + ( + ((UINT64)n->CurrentRTT * (UINT64)9 + + (UINT64)time_span * (UINT64)1) / (UINT64)10 + ); n->TcpSendTimeoutSpan = n->CurrentRTT * 2; } } @@ -5167,18 +5167,18 @@ TCP_RESET: { UINT send_segment_size = MIN(n->TcpSendMaxSegmentSize, send_data_size); void *send_segment = (void *)(( - (UCHAR *)n->SendFifo->p) + n->SendFifo->pos + - current_pointer + send_offset); + (UCHAR *)n->SendFifo->p) + n->SendFifo->pos + + current_pointer + send_offset); SendTcp(v, n->DestIp, n->DestPort, n->SrcIp, n->SrcPort, - (UINT)(n->SendSeqInit + n->SendSeq + (UINT64)current_pointer - + (UINT)send_offset), - (UINT)(n->RecvSeqInit + n->RecvSeq), - TCP_ACK | TCP_PSH, - notice_window_size_value, - 0, - send_segment, - send_segment_size); + (UINT)(n->SendSeqInit + n->SendSeq + (UINT64)current_pointer + + (UINT)send_offset), + (UINT)(n->RecvSeqInit + n->RecvSeq), + TCP_ACK | TCP_PSH, + notice_window_size_value, + 0, + send_segment, + send_segment_size); current_pointer += send_segment_size; send_data_size -= send_segment_size; } @@ -5230,11 +5230,11 @@ TCP_RESET: WriteFifo(n->TcpRecvWindow, NULL, offset + size - FifoSize(n->TcpRecvWindow)); } Copy(((UCHAR *)n->TcpRecvWindow->p) + n->TcpRecvWindow->pos + - offset, data, size); + offset, data, size); me = ZeroMalloc(sizeof(IP_PART)); me->Offset = offset; me->Size = size; - for (i = 0;i < LIST_NUM(n->TcpRecvList);i++) + for (i = 0; i < LIST_NUM(n->TcpRecvList); i++) { IP_PART *p = LIST_DATA(n->TcpRecvList, i); // If there are overlapped region, remove these @@ -5251,7 +5251,7 @@ TCP_RESET: me->Size = 0; } else if (me->Offset > p->Offset && me->Offset < (p->Offset + p->Size) && - (me->Offset + me->Size) > (p->Offset + p->Size)) + (me->Offset + me->Size) > (p->Offset + p->Size)) { // Partially overlapped p->Size -= p->Offset + p->Size - me->Offset; @@ -5273,7 +5273,7 @@ TCP_RESET: } KILL_NULL_FIRST: // Remove all blank items from reception list - for (i = 0;i < LIST_NUM(n->TcpRecvList);i++) + for (i = 0; i < LIST_NUM(n->TcpRecvList); i++) { IP_PART *p = LIST_DATA(n->TcpRecvList, i); if (p->Size == 0) @@ -5285,7 +5285,7 @@ KILL_NULL_FIRST: } SCAN_FIRST: // Extract if there is something starting at offset 0 in the received list - for (i = 0;i < LIST_NUM(n->TcpRecvList);i++) + for (i = 0; i < LIST_NUM(n->TcpRecvList); i++) { IP_PART *p = LIST_DATA(n->TcpRecvList, i); UINT sz; @@ -5301,7 +5301,7 @@ SCAN_FIRST: Free(p); ReadFifo(n->TcpRecvWindow, NULL, sz); // Slide all the items to the left - for (i = 0;i < LIST_NUM(n->TcpRecvList);i++) + for (i = 0; i < LIST_NUM(n->TcpRecvList); i++) { p = LIST_DATA(n->TcpRecvList, i); p->Offset -= sz; @@ -5369,7 +5369,7 @@ void ParseTcpOption(TCP_OPTION *o, void *data, UINT size) return; } value_size -= 2; - + Copy(value, &buf[i], value_size); i += value_size; if (i > size) @@ -5427,7 +5427,7 @@ NAT_ENTRY *CreateNatTcp(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT de } } - // If the connections other than SYN_SENT are too many, delete old ones + // If the connections other than SYN_SENT are too many, delete old ones if (o != NULL && o->SecureNAT_MaxTcpSessionsPerIp != 0) { if (GetNumNatEntriesPerIp(v, src_ip, NAT_TCP, false) >= o->SecureNAT_MaxTcpSessionsPerIp) @@ -5608,7 +5608,7 @@ void PollingNatIcmp(VH *v, NAT_ENTRY *n) icmp->Checksum = IpChecksum(icmp, icmp_size); SendIpEx(v, n->SrcIp, ipv4->SrcIP, ipv4->Protocol, ipv4_payload, ipv4_payload_size, - MAX(ipv4->TimeToLive - 1, 1)); + MAX(ipv4->TimeToLive - 1, 1)); } } } @@ -5654,7 +5654,7 @@ void PoolingNatUdp(VH *v, NAT_ENTRY *n) } SendUdp(v, n->SrcIp, n->SrcPort, src_ip, n->DestPort, - block->Buf, block->Size); + block->Buf, block->Size); FreeBlock(block); } @@ -5678,7 +5678,7 @@ void PoolingNat(VH *v) } // Process by scanning the all NAT entries - for (i = 0;i < LIST_NUM(v->NatTable);i++) + for (i = 0; i < LIST_NUM(v->NatTable); i++) { NAT_ENTRY *n = LIST_DATA(v->NatTable, i); @@ -6106,7 +6106,7 @@ void EncodeNetBiosName(UCHAR *dst, char *src) return; } - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { tmp[i] = ' '; } @@ -6124,7 +6124,7 @@ void EncodeNetBiosName(UCHAR *dst, char *src) tmp[15] = 0; - for (i = 0;i < 16;i++) + for (i = 0; i < 16; i++) { char c = tmp[i]; char *s = CharToNetBiosStr(c); @@ -6141,67 +6141,128 @@ char *CharToNetBiosStr(char c) switch (c) { - case '\0': return "AA"; - case 'A': return "EB"; - case 'B': return "EC"; - case 'C': return "ED"; - case 'D': return "EE"; - case 'E': return "EF"; - case 'F': return "EG"; - case 'G': return "EH"; - case 'H': return "EI"; - case 'I': return "EJ"; - case 'J': return "EK"; - case 'K': return "EL"; - case 'L': return "EM"; - case 'M': return "EN"; - case 'N': return "EO"; - case 'O': return "EP"; - case 'P': return "FA"; - case 'Q': return "FB"; - case 'R': return "FC"; - case 'S': return "FD"; - case 'T': return "FE"; - case 'U': return "FF"; - case 'V': return "FG"; - case 'W': return "FH"; - case 'X': return "FI"; - case 'Y': return "FJ"; - case 'Z': return "FK"; - case '0': return "DA"; - case '1': return "DB"; - case '2': return "DC"; - case '3': return "DD"; - case '4': return "DE"; - case '5': return "DF"; - case '6': return "DG"; - case '7': return "DH"; - case '8': return "DI"; - case '9': return "DJ"; - case ' ': return "CA"; - case '!': return "CB"; - case '\"': return "CC"; - case '#': return "CD"; - case '$': return "CE"; - case '%': return "CF"; - case '&': return "CG"; - case '\'': return "CH"; - case '(': return "CI"; - case ')': return "CJ"; - case '*': return "CK"; - case '+': return "CL"; - case ',': return "CM"; - case '-': return "CN"; - case '.': return "CO"; - case '=': return "DN"; - case ':': return "DK"; - case ';': return "DL"; - case '@': return "EA"; - case '^': return "FO"; - case '_': return "FP"; - case '{': return "HL"; - case '}': return "HN"; - case '~': return "HO"; + case '\0': + return "AA"; + case 'A': + return "EB"; + case 'B': + return "EC"; + case 'C': + return "ED"; + case 'D': + return "EE"; + case 'E': + return "EF"; + case 'F': + return "EG"; + case 'G': + return "EH"; + case 'H': + return "EI"; + case 'I': + return "EJ"; + case 'J': + return "EK"; + case 'K': + return "EL"; + case 'L': + return "EM"; + case 'M': + return "EN"; + case 'N': + return "EO"; + case 'O': + return "EP"; + case 'P': + return "FA"; + case 'Q': + return "FB"; + case 'R': + return "FC"; + case 'S': + return "FD"; + case 'T': + return "FE"; + case 'U': + return "FF"; + case 'V': + return "FG"; + case 'W': + return "FH"; + case 'X': + return "FI"; + case 'Y': + return "FJ"; + case 'Z': + return "FK"; + case '0': + return "DA"; + case '1': + return "DB"; + case '2': + return "DC"; + case '3': + return "DD"; + case '4': + return "DE"; + case '5': + return "DF"; + case '6': + return "DG"; + case '7': + return "DH"; + case '8': + return "DI"; + case '9': + return "DJ"; + case ' ': + return "CA"; + case '!': + return "CB"; + case '\"': + return "CC"; + case '#': + return "CD"; + case '$': + return "CE"; + case '%': + return "CF"; + case '&': + return "CG"; + case '\'': + return "CH"; + case '(': + return "CI"; + case ')': + return "CJ"; + case '*': + return "CK"; + case '+': + return "CL"; + case ',': + return "CM"; + case '-': + return "CN"; + case '.': + return "CO"; + case '=': + return "DN"; + case ':': + return "DK"; + case ';': + return "DL"; + case '@': + return "EA"; + case '^': + return "FO"; + case '_': + return "FP"; + case '{': + return "HL"; + case '}': + return "HN"; + case '~': + return "HO"; } return "CA"; @@ -6255,8 +6316,8 @@ bool ProcessNetBiosNameQueryPacketForMyself(VH *v, UINT src_ip, UINT src_port, U classid = Endian16(classid); if (((flags >> 11) & 0x0F) == 0 && - num_query == 1 && name_size == 0x20 && - zero1 == 0 && zero2 == 0 && zero3 == 0 && node_type == 0 && type == 0x0020 && classid == 0x0001) + num_query == 1 && name_size == 0x20 && + zero1 == 0 && zero2 == 0 && zero3 == 0 && node_type == 0 && type == 0x0020 && classid == 0x0001) { char my_pcname[MAX_SIZE]; @@ -6316,7 +6377,7 @@ bool ProcessNetBiosNameQueryPacketForMyself(VH *v, UINT src_ip, UINT src_port, U UINT i; // Return only private IP if there is a private IP - for (i = 0;i < LIST_NUM(ip_list);i++) + for (i = 0; i < LIST_NUM(ip_list); i++) { IP *ip = LIST_DATA(ip_list, i); @@ -6338,7 +6399,7 @@ bool ProcessNetBiosNameQueryPacketForMyself(VH *v, UINT src_ip, UINT src_port, U if (found == false) { // Return all IP if no private IP are found - for (i = 0;i < LIST_NUM(ip_list);i++) + for (i = 0; i < LIST_NUM(ip_list); i++) { IP *ip = LIST_DATA(ip_list, i); @@ -6524,7 +6585,7 @@ bool ParseDnsPacketEx(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest // Create a DNS entry nat = CreateNatDns(v, src_ip, src_port, dest_ip, dest_port, transaction_id, - false, hostname); + false, hostname); if (nat == false) { @@ -6741,7 +6802,7 @@ BUF *BuildDnsHostName(char *hostname) b = NewBuf(); // Add a host string - for (i = 0;i < token->NumTokens;i++) + for (i = 0; i < token->NumTokens; i++) { size = (UCHAR)StrLen(token->Token[i]); WriteBuf(b, &size, 1); @@ -6784,7 +6845,7 @@ void PollingNatDns(VH *v, NAT_ENTRY *n) // Create a NAT DNS entry NAT_ENTRY *CreateNatDns(VH *v, UINT src_ip, UINT src_port, UINT dest_ip, UINT dest_port, - UINT transaction_id, bool dns_get_ip_from_host, char *dns_target_host_name) + UINT transaction_id, bool dns_get_ip_from_host, char *dns_target_host_name) { NAT_ENTRY *n; HUB_OPTION *o; @@ -7147,7 +7208,7 @@ void PollingIpCombine(VH *v) // Discard the old combining object o = NULL; - for (i = 0;i < LIST_NUM(v->IpCombine);i++) + for (i = 0; i < LIST_NUM(v->IpCombine); i++) { IP_COMBINE *c = LIST_DATA(v->IpCombine, i); @@ -7163,7 +7224,7 @@ void PollingIpCombine(VH *v) if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP_COMBINE *c = LIST_DATA(o, i); @@ -7349,7 +7410,7 @@ void VirtualIcmpEchoRequestReceived(VH *v, UINT src_ip, UINT dst_ip, void *data, { // Process by the Native NAT NnIcmpEchoRecvForInternet(v, src_ip, dst_ip, data, size, ttl, icmp_data, icmp_size, - ip_header, ip_header_size, max_l3_size); + ip_header, ip_header_size, max_l3_size); return; } @@ -7363,7 +7424,7 @@ void VirtualIcmpEchoRequestReceived(VH *v, UINT src_ip, UINT dst_ip, void *data, { // Process in the Raw Socket VirtualIcmpEchoRequestReceivedRaw(v, src_ip, dst_ip, data, size, ttl, icmp_data, icmp_size, - ip_header, ip_header_size); + ip_header, ip_header_size); return; } @@ -7433,7 +7494,7 @@ void VirtualIcmpReceived(VH *v, UINT src_ip, UINT dst_ip, void *data, UINT size, { case ICMP_TYPE_ECHO_REQUEST: // ICMP Echo request VirtualIcmpEchoRequestReceived(v, src_ip, dst_ip, ((UCHAR *)data) + sizeof(ICMP_HEADER), msg_size, ttl, - icmp, size, ip_header, ip_header_size, max_l3_size); + icmp, size, ip_header, ip_header_size, max_l3_size); break; case ICMP_TYPE_ECHO_RESPONSE: // ICMP Echo response @@ -7534,7 +7595,7 @@ void CombineIp(VH *v, IP_COMBINE *c, UINT offset, void *data, UINT size, bool la // Check the overlap between the region which is represented by the offset and size of the // existing received list and the region which is represented by the offset and size - for (i = 0;i < LIST_NUM(c->IpParts);i++) + for (i = 0; i < LIST_NUM(c->IpParts); i++) { UINT moving_size; IP_PART *p = LIST_DATA(c->IpParts, i); @@ -7591,7 +7652,7 @@ void CombineIp(VH *v, IP_COMBINE *c, UINT offset, void *data, UINT size, bool la UINT total_size = 0; UINT i; - for (i = 0;i < LIST_NUM(c->IpParts);i++) + for (i = 0; i < LIST_NUM(c->IpParts); i++) { IP_PART *p = LIST_DATA(c->IpParts, i); @@ -7602,7 +7663,7 @@ void CombineIp(VH *v, IP_COMBINE *c, UINT offset, void *data, UINT size, bool la { // Received all of the IP packet IpReceived(v, c->SrcIP, c->DestIP, c->Protocol, c->Data, c->Size, c->MacBroadcast, c->Ttl, - c->HeadIpHeaderData, c->HeadIpHeaderDataSize, c->SrcIsLocalMacAddr, c->MaxL3Size); + c->HeadIpHeaderData, c->HeadIpHeaderDataSize, c->SrcIsLocalMacAddr, c->MaxL3Size); // Release the combining object FreeIpCombine(v, c); @@ -7628,7 +7689,7 @@ void FreeIpCombine(VH *v, IP_COMBINE *c) Free(c->Data); // Release the partial list - for (i = 0;i < LIST_NUM(c->IpParts);i++) + for (i = 0; i < LIST_NUM(c->IpParts); i++) { IP_PART *p = LIST_DATA(c->IpParts, i); @@ -7722,7 +7783,7 @@ void FreeIpCombineList(VH *v) return; } - for (i = 0;i < LIST_NUM(v->IpCombine);i++) + for (i = 0; i < LIST_NUM(v->IpCombine); i++) { IP_COMBINE *c = LIST_DATA(v->IpCombine, i); @@ -7845,7 +7906,7 @@ void VirtualIpReceived(VH *v, PKT *packet) // Because this packet has not been fragmented, it can be delivered to the upper layer immediately head_ip_header_data = (UCHAR *)packet->L3.IPv4Header; IpReceived(v, ip->SrcIP, ip->DstIP, ip->Protocol, data, size, packet->BroadcastPacket, ip->TimeToLive, - head_ip_header_data, head_ip_header_size, is_local_mac, ip_l3_size); + head_ip_header_data, head_ip_header_size, is_local_mac, ip_l3_size); } else { @@ -7870,8 +7931,8 @@ void VirtualIpReceived(VH *v, PKT *packet) { // Create a combining object because it is the first packet c = InsertIpCombine( - v, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol, packet->BroadcastPacket, - ip->TimeToLive, is_local_mac); + v, ip->SrcIP, ip->DstIP, Endian16(ip->Identification), ip->Protocol, packet->BroadcastPacket, + ip->TimeToLive, is_local_mac); if (c != NULL) { c->MaxL3Size = ip_l3_size; @@ -7894,7 +7955,7 @@ void SendWaitingIp(VH *v, UCHAR *mac, UINT dest_ip) } // Get a target list - for (i = 0;i < LIST_NUM(v->IpWaitTable);i++) + for (i = 0; i < LIST_NUM(v->IpWaitTable); i++) { IP_WAIT *w = LIST_DATA(v->IpWaitTable, i); @@ -7911,7 +7972,7 @@ void SendWaitingIp(VH *v, UCHAR *mac, UINT dest_ip) // Send the target packets at once if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP_WAIT *w = LIST_DATA(o, i); @@ -7942,7 +8003,7 @@ void DeleteOldIpWaitTable(VH *v) } // Get the deleting list - for (i = 0;i < LIST_NUM(v->IpWaitTable);i++) + for (i = 0; i < LIST_NUM(v->IpWaitTable); i++) { IP_WAIT *w = LIST_DATA(v->IpWaitTable, i); @@ -7959,7 +8020,7 @@ void DeleteOldIpWaitTable(VH *v) // Delete all at once if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { IP_WAIT *w = LIST_DATA(o, i); @@ -8023,7 +8084,7 @@ void FreeIpWaitTable(VH *v) return; } - for (i = 0;i < LIST_NUM(v->IpWaitTable);i++) + for (i = 0; i < LIST_NUM(v->IpWaitTable); i++) { IP_WAIT *w = LIST_DATA(v->IpWaitTable, i); @@ -8068,7 +8129,7 @@ void PollingArpWaitTable(VH *v) o = NULL; // Scan whole ARP waiting list - for (i = 0;i < LIST_NUM(v->ArpWaitTable);i++) + for (i = 0; i < LIST_NUM(v->ArpWaitTable); i++) { ARP_WAIT *w = LIST_DATA(v->ArpWaitTable, i); @@ -8099,7 +8160,7 @@ void PollingArpWaitTable(VH *v) // Remove if there is a ARP waiting record to be deleted if (o != NULL) { - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { ARP_WAIT *w = LIST_DATA(o, i); @@ -8210,7 +8271,7 @@ void FreeArpWaitTable(VH *v) return; } - for (i = 0;i < LIST_NUM(v->ArpWaitTable);i++) + for (i = 0; i < LIST_NUM(v->ArpWaitTable); i++) { ARP_WAIT *w = LIST_DATA(v->ArpWaitTable, i); @@ -8285,7 +8346,7 @@ void RefreshArpTable(VH *v) } o = NewListFast(NULL); - for (i = 0;i < LIST_NUM(v->ArpTable);i++) + for (i = 0; i < LIST_NUM(v->ArpTable); i++) { ARP_ENTRY *e = LIST_DATA(v->ArpTable, i); @@ -8298,7 +8359,7 @@ void RefreshArpTable(VH *v) } // Remove expired entries at once - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { ARP_ENTRY *e = LIST_DATA(o, i); @@ -8348,7 +8409,7 @@ void FreeArpTable(VH *v) } // Delete all entries - for (i = 0;i < LIST_NUM(v->ArpTable);i++) + for (i = 0; i < LIST_NUM(v->ArpTable); i++) { ARP_ENTRY *e = LIST_DATA(v->ArpTable, i); Free(e); @@ -8570,7 +8631,7 @@ void PollingBeacon(VH *v) } if (v->LastSendBeacon == 0 || - ((v->LastSendBeacon + BEACON_SEND_INTERVAL) <= Tick64())) + ((v->LastSendBeacon + BEACON_SEND_INTERVAL) <= Tick64())) { v->LastSendBeacon = Tick64(); @@ -8590,7 +8651,7 @@ void VirtualLayer2Send(VH *v, UCHAR *dest_mac, UCHAR *src_mac, USHORT protocol, return; } - // Create buffer + // Create buffer buf = Malloc(MAC_HEADER_SIZE + size); // MAC header @@ -8605,7 +8666,7 @@ void VirtualLayer2Send(VH *v, UCHAR *dest_mac, UCHAR *src_mac, USHORT protocol, // Size size += sizeof(MAC_HEADER); - // Generate the packet + // Generate the packet block = NewBlock(buf, size, 0); // Insert into the queue @@ -8665,7 +8726,7 @@ void SendIpEx(VH *v, UINT dest_ip, UINT src_ip, UCHAR protocol, void *data, UINT // Transmit the fragmented packet SendFragmentedIp(v, dest_ip, src_ip, id, - total_size, offset, protocol, buf + offset, size_of_this_packet, NULL, ttl); + total_size, offset, protocol, buf + offset, size_of_this_packet, NULL, ttl); if (last_packet) { break; @@ -8723,7 +8784,7 @@ void SendFragmentedIp(VH *v, UINT dest_ip, UINT src_ip, USHORT id, USHORT total_ if (dest_mac == NULL) { if (ip->DstIP == 0xffffffff || - (IsInNetwork(ip->DstIP, v->HostIP, v->HostMask) && (ip->DstIP & (~v->HostMask)) == (~v->HostMask))) + (IsInNetwork(ip->DstIP, v->HostIP, v->HostMask) && (ip->DstIP & (~v->HostMask)) == (~v->HostMask))) { // Broadcast address dest_mac = broadcast; @@ -9100,7 +9161,7 @@ void PollingDhcpServer(VH *v) if (v->LastDhcpPolling != 0) { if ((v->LastDhcpPolling + (UINT64)DHCP_POLLING_INTERVAL) > v->Now && - v->LastDhcpPolling < v->Now) + v->LastDhcpPolling < v->Now) { return; } @@ -9185,7 +9246,7 @@ UINT ServeDhcpDiscover(VH *v, UCHAR *mac, UINT request_ip) { // Examine whether the specified IP address is within the range of assignment if (Endian32(v->DhcpIpStart) <= Endian32(request_ip) && - Endian32(request_ip) <= Endian32(v->DhcpIpEnd)) + Endian32(request_ip) <= Endian32(v->DhcpIpEnd)) { // Accept if within the range ret = request_ip; @@ -9196,7 +9257,7 @@ UINT ServeDhcpDiscover(VH *v, UCHAR *mac, UINT request_ip) { // Examine whether the specified IP address is within the range of assignment if (Endian32(v->DhcpIpStart) <= Endian32(request_ip) && - Endian32(request_ip) <= Endian32(v->DhcpIpEnd)) + Endian32(request_ip) <= Endian32(v->DhcpIpEnd)) { // Accept if within the range ret = request_ip; @@ -9222,7 +9283,7 @@ UINT ServeDhcpDiscover(VH *v, UCHAR *mac, UINT request_ip) { // Examine whether the found IP address is in the allocation region if (Endian32(v->DhcpIpStart) <= Endian32(d->IpAddress) && - Endian32(d->IpAddress) <= Endian32(v->DhcpIpEnd)) + Endian32(d->IpAddress) <= Endian32(v->DhcpIpEnd)) { // Use the IP address if it's found within the range ret = d->IpAddress; @@ -9262,7 +9323,7 @@ UINT GetFreeDhcpIpAddress(VH *v) ip_start = Endian32(v->DhcpIpStart); ip_end = Endian32(v->DhcpIpEnd); - for (i = ip_start; i <= ip_end;i++) + for (i = ip_start; i <= ip_end; i++) { UINT ip = Endian32(i); if (SearchDhcpLeaseByIp(v, ip) == NULL && SearchDhcpPendingLeaseByIp(v, ip) == NULL) @@ -9299,7 +9360,7 @@ UINT GetFreeDhcpIpAddressByRandom(VH *v, UCHAR *mac) num_retry = (ip_end - ip_start + 1) * 2; num_retry = MIN(num_retry, 65536 * 2); - for (i = 0;i < num_retry;i++) + for (i = 0; i < num_retry; i++) { UCHAR rand_seed[sizeof(UINT) + 6]; UCHAR hash[16]; @@ -9582,7 +9643,7 @@ void VirtualDhcpServer(VH *v, PKT *p) } // Transmission VirtualDhcpSend(v, tran_id, dest_ip, Endian16(p->L4.UDPHeader->SrcPort), - ip, dhcp->ClientMacAddress, b, dhcp->HardwareType, dhcp->HardwareAddressSize); + ip, dhcp->ClientMacAddress, b, dhcp->HardwareType, dhcp->HardwareAddressSize); // Release the memory FreeBuf(b); @@ -9617,7 +9678,7 @@ void VirtualDhcpServer(VH *v, PKT *p) } // Transmission VirtualDhcpSend(v, tran_id, dest_ip, Endian16(p->L4.UDPHeader->SrcPort), - ip, dhcp->ClientMacAddress, b, dhcp->HardwareType, dhcp->HardwareAddressSize); + ip, dhcp->ClientMacAddress, b, dhcp->HardwareType, dhcp->HardwareAddressSize); // Release the memory FreeBuf(b); @@ -9633,7 +9694,7 @@ void VirtualDhcpServer(VH *v, PKT *p) // Submit the DHCP response packet void VirtualDhcpSend(VH *v, UINT tran_id, UINT dest_ip, UINT dest_port, - UINT new_ip, UCHAR *client_mac, BUF *b, UINT hw_type, UINT hw_addr_size) + UINT new_ip, UCHAR *client_mac, BUF *b, UINT hw_type, UINT hw_addr_size) { UINT blank_size = 128 + 64; UINT dhcp_packet_size; @@ -9924,7 +9985,7 @@ void SetVirtualHostOption(VH *v, VH_OPTION *vo) LockVirtual(v); { // Set the MAC address - for (i = 0;i < 6;i++) + for (i = 0; i < 6; i++) { if (vo->MacAddress[i] != 0) { @@ -9974,8 +10035,8 @@ void SetVirtualHostOption(VH *v, VH_OPTION *vo) else { v->DhcpExpire = MAKESURE(DHCP_MIN_EXPIRE_TIMESPAN, - MIN(vo->DhcpExpireTimeSpan * 1000, 2000000000), - INFINITE); + MIN(vo->DhcpExpireTimeSpan * 1000, 2000000000), + INFINITE); } // Address range to be distributed @@ -10261,7 +10322,7 @@ void GenMacAddress(UCHAR *mac) PACKET_ADAPTER *VirtualGetPacketAdapter() { return NewPacketAdapter(VirtualPaInit, VirtualPaGetCancel, - VirtualPaGetNextPacket, VirtualPaPutPacket, VirtualPaFree); + VirtualPaGetNextPacket, VirtualPaPutPacket, VirtualPaFree); } diff --git a/src/Mayaqua/Network.c b/src/Mayaqua/Network.c index 75365d97..a80423d7 100644 --- a/src/Mayaqua/Network.c +++ b/src/Mayaqua/Network.c @@ -2398,6 +2398,7 @@ void RUDPBulkSend(RUDP_STACK *r, RUDP_SESSION *se, void *data, UINT data_size) { UCHAR *buf; UINT i, icmp_type, buf_size, padding_size; + icmp_type = 0; // Validate arguments if (r == NULL || se == NULL || (data == NULL && data_size != 0)) { From a2a6502ab90b1f81cc95a66a993fdefc6ea84992 Mon Sep 17 00:00:00 2001 From: Evengard Date: Tue, 12 May 2020 01:16:58 +0300 Subject: [PATCH 4/6] Numerous fixes. First working version. --- src/Cedar/IPC.c | 63 +++++++++++++++++++++++++++++++++++++------------ src/Cedar/IPC.h | 4 ++-- 2 files changed, 50 insertions(+), 17 deletions(-) diff --git a/src/Cedar/IPC.c b/src/Cedar/IPC.c index 899238b5..0cf2b432 100644 --- a/src/Cedar/IPC.c +++ b/src/Cedar/IPC.c @@ -1350,9 +1350,8 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) if (Cmp(dest_mac, ipc->MacAddress, 6) == 0 || IsMacBroadcast(dest_mac) || IsMacMulticast(dest_mac)) { // If the source MAC address is itselves or invalid address, ignore the packet - if (Cmp(src_mac, ipc->MacAddress, 6) != 0 && !IsMacUnicast(src_mac)) + if (Cmp(src_mac, ipc->MacAddress, 6) != 0 && IsMacUnicast(src_mac)) { - Debug("Received packed for L3 parsing\n"); if (protocol == MAC_PROTO_ARPV4) { // ARP receiving process @@ -1360,7 +1359,6 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) } else if (protocol == MAC_PROTO_IPV4) { - Debug("MAC_PROTO_IPV4\n"); // IPv4 receiving process if (b->Size >= (14 + 20)) { @@ -1456,9 +1454,9 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) { IP ip_src, ip_dst; bool ndtProcessed = false; - UINT size = p->L3.IPv6Header->PayloadLength + sizeof(IPV6_HEADER); + UINT size = b->Size - 14; - UCHAR *data = Clone(p->L3.IPv6Header, size); + UCHAR *data = Clone(b->Buf + 14, size); IPv6AddrToIP(&ip_src, &p->IPv6HeaderPacketInfo.IPv6Header->SrcAddress); IPv6AddrToIP(&ip_dst, &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress); @@ -2177,7 +2175,7 @@ bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, UINT64 eui) ZeroIP6(&i.Ip); i.Ip.ipv6_addr[0] = 0xFE; i.Ip.ipv6_addr[1] = 0x80; - WRITE_UINT64(&i.Ip.ipv6_addr[8], &eui); + Copy(&i.Ip.ipv6_addr[8], &eui, sizeof(UINT64)); h = Search(ipc->Cedar->HubList, &t); @@ -2274,24 +2272,25 @@ UINT64 IPCIPv6GetServerEui(IPC *ipc) // Generate link local from client's EUI linkLocal.Value[0] = 0xFE; linkLocal.Value[1] = 0x80; - WRITE_UINT64(&linkLocal.Value[8], &ipc->IPv6ClientEUI); + Copy(&linkLocal.Value[8], &ipc->IPv6ClientEUI, sizeof(UINT64)); GetAllRouterMulticastAddress6(&destIP); // Generate the MAC address from the multicast address destMacAddress[0] = 0x33; destMacAddress[1] = 0x33; - WRITE_UINT(&destMacAddress[2], &destIP.ipv6_addr[12]); + Copy(&destMacAddress[2], &destIP.ipv6_addr[12], sizeof(UINT)); IPToIPv6Addr(&senderV6, &senderIP); IPToIPv6Addr(&destV6, &destIP); packet = BuildICMPv6RouterSoliciation(&senderV6, &destV6, ipc->MacAddress, 0); + UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); + while (LIST_NUM(ipc->IPv6RouterAdvs) == 0) { - UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); - UINT64 timeout_retry = Tick() + (UINT64)IPC_IPV6_RA_INTERVAL; + UINT64 timeout_retry = Tick64() + (UINT64)IPC_IPV6_RA_INTERVAL; IPCIPv6SendWithDestMacAddr(ipc, packet->Buf, packet->Size, destMacAddress); AddInterrupt(ipc->Interrupt, timeout_retry); @@ -2311,7 +2310,17 @@ UINT64 IPCIPv6GetServerEui(IPC *ipc) 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]); + Copy(&ipc->IPv6ServerEUI, &ra->RouterAddress.ipv6_addr[8], sizeof(UINT64)); + } + + // If it is still not defined, let's just generate something random + while (ipc->IPv6ServerEUI == 0) + { + ipc->IPv6ServerEUI = Rand64(); + if (ipc->IPv6ClientEUI == ipc->IPv6ServerEUI) + { + ipc->IPv6ServerEUI = 0; + } } return ipc->IPv6ServerEUI; @@ -2454,15 +2463,39 @@ void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip) ndtMatch = IPCNewARP(next_ip, NULL); Add(ipc->IPv6NeighborTable, ndtMatch); } + + if (ndtMatch->Resolved != true && LIST_NUM(ipc->IPv6RouterAdvs) > 0) + { + // First try to look up in router advertisements + UINT i; + for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) + { + IPC_IPV6_ROUTER_ADVERTISEMENT *ra = LIST_DATA(ipc->IPv6RouterAdvs, i); + if (CmpIpAddr(next_ip, &ra->RouterAddress) == 0) + { + Copy(ndtMatch->MacAddress, IsMacUnicast(ra->RouterLinkLayerAddress) ? ra->RouterLinkLayerAddress : ra->RouterMacAddress, 6); + ndtMatch->Resolved = true; + break; + } + } + } + if (ndtMatch->Resolved != true) { - /// 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 + // We need to send the Neighbor Solicitation and save the packet for sending later + // Generate the MAC address from the multicast address + UCHAR destMacAddress[6]; + BUF *neighborSolicit = BuildICMPv6NeighborSoliciation(&header->SrcAddress, &header->DestAddress, ipc->MacAddress, 0); + destMacAddress[0] = 0x33; + destMacAddress[1] = 0x33; + Copy(&destMacAddress[2], &next_ip->ipv6_addr[12], sizeof(UINT)); + IPCIPv6SendWithDestMacAddr(ipc, neighborSolicit->Buf, neighborSolicit->Size, destMacAddress); + CHAR tmp[MAX_SIZE]; - BLOCK *blk = NewBlock(data, size, 0); + UCHAR *copy = Clone(data, size); + BLOCK *blk = NewBlock(copy, size, 0); InsertQueue(ndtMatch->PacketQueue, blk); 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); return; } diff --git a/src/Cedar/IPC.h b/src/Cedar/IPC.h index 3160f1d1..654ad428 100644 --- a/src/Cedar/IPC.h +++ b/src/Cedar/IPC.h @@ -27,8 +27,8 @@ // IPv6 constants #define IPC_IPV6_NDT_LIFETIME (30 * 1000) // as per REACHABLE_TIME constant of RFC4861 #define IPC_IPV6_NDT_GIVEUPTIME (3 * 1000) // as per MAX_MULTICAST_SOLICIT * RETRANS_TIMER constants of RFC4861 -#define IPC_IPV6_RA_INTERVAL (4 * 1000) // as per RTR_SOLICITATION_INTERVAL constant of RFC4861 -#define IPC_IPV6_RA_MAX_RETRIES 3 // as per MAX_RTR_SOLICITATIONS constant of RFC4861 +#define IPC_IPV6_RA_INTERVAL (2 * 1000) // Windows gets stuck if it is bigger +#define IPC_IPV6_RA_MAX_RETRIES 2 // Windows seems to be stuck when it doesn't receive an answer in due time // Protocol status #define IPC_PROTO_STATUS_CLOSED 0x0 From 2cfe0313980e3f46dcc5ac8c0a095b499d45f4f6 Mon Sep 17 00:00:00 2001 From: Evengard Date: Tue, 12 May 2020 03:30:59 +0300 Subject: [PATCH 5/6] Fixing most errors, the link on Windows is working and is stable --- src/Cedar/IPC.c | 144 +++++++++++--- src/Cedar/IPC.h | 2 +- src/Cedar/Logging.c | 432 +++++++++++++++++++++--------------------- src/Cedar/Proto_PPP.c | 6 +- src/Mayaqua/TcpIp.c | 43 ++++- src/Mayaqua/TcpIp.h | 4 +- 6 files changed, 384 insertions(+), 247 deletions(-) diff --git a/src/Cedar/IPC.c b/src/Cedar/IPC.c index 0cf2b432..e455c101 100644 --- a/src/Cedar/IPC.c +++ b/src/Cedar/IPC.c @@ -1428,7 +1428,7 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) } } - FreePacket(pkt); + FreePacketWithData(pkt); } IPCAssociateOnArpTable(ipc, &ip_src, src_mac); @@ -1438,6 +1438,10 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) // Place in the reception queue InsertQueue(ipc->IPv4ReceivedQueue, NewBlock(data, size, 0)); } + else + { + Free(data); // We need to free the packet if we don't save it + } } else @@ -1470,9 +1474,9 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) { case ICMPV6_TYPE_ROUTER_ADVERTISEMENT: // We save the router advertisement data for later use - IPCIPv6AddRouterPrefix(ipc, &p->ICMPv6HeaderPacketInfo.OptionList, src_mac, &ip_src); + IPCIPv6AddRouterPrefixes(ipc, &p->ICMPv6HeaderPacketInfo.OptionList, src_mac, &ip_src); IPCIPv6AssociateOnNDTEx(ipc, &ip_src, src_mac, true); - IPCIPv6AssociateOnNDTEx(ipc, &ip_src, &p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer->Address, true); + IPCIPv6AssociateOnNDTEx(ipc, &ip_src, p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer->Address, true); break; case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: // We save the neighbor advertisements into NDT @@ -1495,6 +1499,10 @@ void IPCProcessL3EventsEx(IPC *ipc, UINT64 now) { InsertQueue(ipc->IPv6ReceivedQueue, NewBlock(data, size, 0)); } + else + { + Free(data); // We need to free the packet if we don't save it + } FreePacket(p); } @@ -2192,30 +2200,40 @@ bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, UINT64 eui) } // RA -void IPCIPv6AddRouterPrefix(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip) +void IPCIPv6AddRouterPrefixes(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip) { - UINT i; - bool foundPrefix = false; - for (i = 0; i < LIST_NUM(ipc->IPv6RouterAdvs); i++) + UINT i, j; + for (i = 0; i < ICMPV6_OPTION_PREFIXES_MAX_COUNT; 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 (recvPrefix->Prefix[i] != NULL) + { + bool foundPrefix = false; + for (j = 0; j < LIST_NUM(ipc->IPv6RouterAdvs); j++) + { + IPC_IPV6_ROUTER_ADVERTISEMENT *existingRA = LIST_DATA(ipc->IPv6RouterAdvs, j); + if (Cmp(&recvPrefix->Prefix[i]->Prefix, &existingRA->RoutedPrefix.ipv6_addr, sizeof(IPV6_ADDR)) == 0) + { + foundPrefix = true; + break; + } + } + + if (!foundPrefix) + { + IPC_IPV6_ROUTER_ADVERTISEMENT *newRA = Malloc(sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); + IPv6AddrToIP(&newRA->RoutedPrefix, &recvPrefix->Prefix[i]->Prefix); + IntToSubnetMask6(&newRA->RoutedMask, recvPrefix->Prefix[i]->SubnetLength); + CopyIP(&newRA->RouterAddress, ip); + Copy(newRA->RouterMacAddress, macAddress, 6); + Copy(newRA->RouterLinkLayerAddress, recvPrefix->SourceLinkLayer->Address, 6); + Add(ipc->IPv6RouterAdvs, newRA); + } + } + else { - foundPrefix = true; break; } } - - if (!foundPrefix) - { - IPC_IPV6_ROUTER_ADVERTISEMENT *newRA = Malloc(sizeof(IPC_IPV6_ROUTER_ADVERTISEMENT)); - IPv6AddrToIP(&newRA->RoutedPrefix, &recvPrefix->Prefix->Prefix); - IntToSubnetMask6(&newRA->RoutedMask, recvPrefix->Prefix->SubnetLength); - CopyIP(&newRA->RouterAddress, ip); - Copy(newRA->RouterMacAddress, macAddress, 6); - Copy(newRA->RouterLinkLayerAddress, recvPrefix->SourceLinkLayer->Address, 6); - Add(ipc->IPv6RouterAdvs, newRA); - } } bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVERTISEMENT *matchedRA) @@ -2287,11 +2305,16 @@ UINT64 IPCIPv6GetServerEui(IPC *ipc) packet = BuildICMPv6RouterSoliciation(&senderV6, &destV6, ipc->MacAddress, 0); UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); + UINT64 timeout_retry = 0; while (LIST_NUM(ipc->IPv6RouterAdvs) == 0) { - UINT64 timeout_retry = Tick64() + (UINT64)IPC_IPV6_RA_INTERVAL; - IPCIPv6SendWithDestMacAddr(ipc, packet->Buf, packet->Size, destMacAddress); + UINT64 now = Tick64(); + if (now >= timeout_retry) + { + timeout_retry = now + (UINT64)IPC_IPV6_RA_INTERVAL; + IPCIPv6SendWithDestMacAddr(ipc, packet->Buf, packet->Size, destMacAddress); + } AddInterrupt(ipc->Interrupt, timeout_retry); @@ -2304,6 +2327,8 @@ UINT64 IPCIPv6GetServerEui(IPC *ipc) // The processing should populate the received RAs by itself IPCProcessL3Events(ipc); } + + FreeBuf(packet); } // Populating the IPv6 Server EUI for IPV6CP @@ -2379,6 +2404,10 @@ void IPCIPv6Send(IPC *ipc, void *data, UINT size) void IPCIPv6SendWithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac_addr) { UCHAR tmp[1514]; + + IPV6_HEADER *header = data; + + // Validate arguments if (ipc == NULL || data == NULL || size < 40 || size > 1500 || dest_mac_addr == NULL) { @@ -2397,6 +2426,60 @@ void IPCIPv6SendWithDestMacAddr(IPC *ipc, void *data, UINT size, UCHAR *dest_mac // Data Copy(tmp + 14, data, size); + // Parse the packet for ND ICMPv6 fixup + if (header->NextHeader == IP_PROTO_ICMPV6) + { + PKT *p = ParsePacketUpToICMPv6(tmp, size + 14); + if (p != NULL) + { + ICMPV6_OPTION_LINK_LAYER linkLayer; + BUF *buf; + BUF *optBuf; + BUF *packet; + // We need to rebuild the packet to + switch (p->ICMPv6HeaderPacketInfo.Type) + { + case ICMPV6_TYPE_NEIGHBOR_SOLICIATION: + if (p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer == NULL) + { + p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer = &linkLayer; + } + Copy(p->ICMPv6HeaderPacketInfo.OptionList.SourceLinkLayer->Address, ipc->MacAddress, 6); + case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: + if (p->ICMPv6HeaderPacketInfo.OptionList.TargetLinkLayer == NULL) + { + p->ICMPv6HeaderPacketInfo.OptionList.TargetLinkLayer = &linkLayer; + } + Copy(p->ICMPv6HeaderPacketInfo.OptionList.TargetLinkLayer->Address, ipc->MacAddress, 6); + } + switch (p->ICMPv6HeaderPacketInfo.Type) + { + case ICMPV6_TYPE_NEIGHBOR_SOLICIATION: + case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: + optBuf = BuildICMPv6Options(&p->ICMPv6HeaderPacketInfo.OptionList); + buf = NewBuf(); + WriteBuf(buf, p->ICMPv6HeaderPacketInfo.Headers.HeaderPointer, + p->ICMPv6HeaderPacketInfo.Type == ICMPV6_TYPE_NEIGHBOR_SOLICIATION ? sizeof(ICMPV6_NEIGHBOR_SOLICIATION_HEADER) : sizeof(ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER)); + WriteBufBuf(buf, optBuf); + packet = BuildICMPv6(&p->IPv6HeaderPacketInfo.IPv6Header->SrcAddress, + &p->IPv6HeaderPacketInfo.IPv6Header->DestAddress, + p->IPv6HeaderPacketInfo.IPv6Header->HopLimit, + p->ICMPv6HeaderPacketInfo.Type, + p->ICMPv6HeaderPacketInfo.Code, + buf->Buf, + buf->Size, + 0); + Copy(tmp + 14, packet->Buf, packet->Size); + size = packet->Size; + FreeBuf(optBuf); + FreeBuf(buf); + FreeBuf(packet); + break; + } + } + FreePacket(p); + } + // Send IPCSendL2(ipc, tmp, size + 14); } @@ -2484,13 +2567,24 @@ void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip) { // We need to send the Neighbor Solicitation and save the packet for sending later // Generate the MAC address from the multicast address + BUF *neighborSolicit; UCHAR destMacAddress[6]; - BUF *neighborSolicit = BuildICMPv6NeighborSoliciation(&header->SrcAddress, &header->DestAddress, ipc->MacAddress, 0); + IPV6_ADDR solicitAddress; + Zero(&solicitAddress, sizeof(IPV6_ADDR)); + Copy(&solicitAddress.Value[13], &header->DestAddress.Value[13], 3); + solicitAddress.Value[0] = 0xFF; + solicitAddress.Value[1] = 0x02; + solicitAddress.Value[11] = 0x01; + solicitAddress.Value[12] = 0xFF; + + neighborSolicit = BuildICMPv6NeighborSoliciation(&header->SrcAddress, &solicitAddress, ipc->MacAddress, 0); destMacAddress[0] = 0x33; destMacAddress[1] = 0x33; - Copy(&destMacAddress[2], &next_ip->ipv6_addr[12], sizeof(UINT)); + Copy(&destMacAddress[2], &solicitAddress.Value[12], sizeof(UINT)); IPCIPv6SendWithDestMacAddr(ipc, neighborSolicit->Buf, neighborSolicit->Size, destMacAddress); + FreeBuf(neighborSolicit); + CHAR tmp[MAX_SIZE]; UCHAR *copy = Clone(data, size); BLOCK *blk = NewBlock(copy, size, 0); diff --git a/src/Cedar/IPC.h b/src/Cedar/IPC.h index 654ad428..bd68c176 100644 --- a/src/Cedar/IPC.h +++ b/src/Cedar/IPC.h @@ -227,7 +227,7 @@ void IPCIPv6FlushNDT(IPC *ipc); void IPCIPv6FlushNDTEx(IPC *ipc, UINT64 now); bool IPCIPv6CheckExistingLinkLocal(IPC *ipc, UINT64 eui); // RA -void IPCIPv6AddRouterPrefix(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip); +void IPCIPv6AddRouterPrefixes(IPC *ipc, ICMPV6_OPTION_LIST *recvPrefix, UCHAR *macAddress, IP *ip); bool IPCIPv6CheckUnicastFromRouterPrefix(IPC *ipc, IP *ip, IPC_IPV6_ROUTER_ADVERTISEMENT *matchedRA); UINT64 IPCIPv6GetServerEui(IPC *ipc); // Data flow diff --git a/src/Cedar/Logging.c b/src/Cedar/Logging.c index 9b89f5f4..ff79ef48 100644 --- a/src/Cedar/Logging.c +++ b/src/Cedar/Logging.c @@ -175,7 +175,7 @@ void FreeEraseFileList(LIST *o) return; } - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { ERASE_FILE *f = LIST_DATA(o, i); Free(f->FullPath); @@ -200,7 +200,7 @@ void EnumEraseFile(LIST *o, char *dirname) // Enumeration dir = EnumDir(dirname); - for (i = 0;i < dir->NumFiles;i++) + for (i = 0; i < dir->NumFiles; i++) { DIRENT *e = dir->File[i]; Format(tmp, sizeof(tmp), "%s/%s", dirname, e->FileName); @@ -245,7 +245,7 @@ LIST *GenerateEraseFileList(ERASER *e) o = NewListFast(CompareEraseFile); // Scan for each directory - for (i = 0;i < sizeof(delete_targets) / sizeof(delete_targets[0]);i++) + for (i = 0; i < sizeof(delete_targets) / sizeof(delete_targets[0]); i++) { char dirname[MAX_PATH]; Format(dirname, sizeof(dirname), "%s/%s", e->DirName, delete_targets[i]); @@ -285,7 +285,7 @@ void EraserMain(ERASER *e) o = GenerateEraseFileList(e); // Try to delete one by one in order from oldest file - for (i = 0;i < LIST_NUM(o);i++) + for (i = 0; i < LIST_NUM(o); i++) { ERASE_FILE *f = LIST_DATA(o, i); @@ -626,7 +626,7 @@ void EtherIPLog(ETHERIP_SERVER *s, char *name, ...) IPToStr(client_ip, sizeof(client_ip), &s->ClientIP); UniFormat(prefix, sizeof(prefix), _UU("LE_PREFIX"), s->Id, - server_ip, s->ServerPort, client_ip, s->ClientPort); + server_ip, s->ServerPort, client_ip, s->ClientPort); va_start(args, name); UniFormatArgs(buf2, sizeof(buf2), _UU(name), args); @@ -671,17 +671,17 @@ void IPsecLog(IKE_SERVER *ike, IKE_CLIENT *c, IKE_SA *ike_sa, IPSECSA *ipsec_sa, if (ipsec_sa != NULL) { UniFormat(prefix, sizeof(prefix), _UU("LI_PREFIX_IPSEC"), - ipsec_sa->Id, c->Id, client_ip, c->ClientPort, server_ip, c->ServerPort); + ipsec_sa->Id, c->Id, client_ip, c->ClientPort, server_ip, c->ServerPort); } else if (ike_sa != NULL) { UniFormat(prefix, sizeof(prefix), _UU("LI_PREFIX_IKE"), - ike_sa->Id, c->Id, client_ip, c->ClientPort, server_ip, c->ServerPort); + ike_sa->Id, c->Id, client_ip, c->ClientPort, server_ip, c->ServerPort); } else { UniFormat(prefix, sizeof(prefix), _UU("LI_PREFIX_CLIENT"), - c->Id, client_ip, c->ClientPort, server_ip, c->ServerPort); + c->Id, client_ip, c->ClientPort, server_ip, c->ServerPort); } } @@ -755,7 +755,7 @@ void WriteHubLog(HUB *h, wchar_t *str) } if (syslog_status == SYSLOG_SERVER_AND_HUB_SECURITY_LOG - || syslog_status == SYSLOG_SERVER_AND_HUB_ALL_LOG) + || syslog_status == SYSLOG_SERVER_AND_HUB_ALL_LOG) { SiWriteSysLog(s, "SECURITY_LOG", h->Name, str); } @@ -833,7 +833,7 @@ bool PacketLog(HUB *hub, SESSION *src_session, SESSION *dest_session, PKT *packe } if (memcmp(hub->HubMacAddr, packet->MacAddressSrc, 6) == 0 || - memcmp(hub->HubMacAddr, packet->MacAddressDest, 6) == 0) + memcmp(hub->HubMacAddr, packet->MacAddressDest, 6) == 0) { return true; } @@ -1027,8 +1027,8 @@ UINT CalcPacketLoggingLevelEx(HUB_LOG *g, PKT *packet) ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP]); if (packet->L4.TCPHeader->Flag & TCP_SYN || - packet->L4.TCPHeader->Flag & TCP_RST || - packet->L4.TCPHeader->Flag & TCP_FIN) + packet->L4.TCPHeader->Flag & TCP_RST || + packet->L4.TCPHeader->Flag & TCP_FIN) { // TCP SYN LOG ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); @@ -1057,10 +1057,10 @@ UINT CalcPacketLoggingLevelEx(HUB_LOG *g, PKT *packet) ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); break; - case L7_DNS: - // DNS request - ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); - break; + case L7_DNS: + // DNS request + ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); + break; } break; @@ -1084,8 +1084,8 @@ UINT CalcPacketLoggingLevelEx(HUB_LOG *g, PKT *packet) ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP]); if (packet->L4.TCPHeader->Flag & TCP_SYN || - packet->L4.TCPHeader->Flag & TCP_RST || - packet->L4.TCPHeader->Flag & TCP_FIN) + packet->L4.TCPHeader->Flag & TCP_RST || + packet->L4.TCPHeader->Flag & TCP_FIN) { // TCP SYN LOG ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); @@ -1109,10 +1109,10 @@ UINT CalcPacketLoggingLevelEx(HUB_LOG *g, PKT *packet) ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); break; - case L7_DNS: - // DNS request - ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); - break; + case L7_DNS: + // DNS request + ret = MAX(ret, g->PacketLogConfig[PACKET_LOG_TCP_CONN]); + break; } break; @@ -1167,12 +1167,12 @@ char *BuildHttpLogStr(HTTPLOG *h) if (h->Port == 80) { Format(url, sizeof(url), "http://%s%s", - h->Hostname, h->Path); + h->Hostname, h->Path); } else { Format(url, sizeof(url), "http://%s:%u%s", - h->Hostname, h->Port, h->Path); + h->Hostname, h->Port, h->Path); } } else @@ -1180,12 +1180,12 @@ char *BuildHttpLogStr(HTTPLOG *h) if (h->Port == 443) { Format(url, sizeof(url), "https://%s/", - h->Hostname); + h->Hostname); } else { Format(url, sizeof(url), "https://%s:%u/", - h->Hostname, h->Port); + h->Hostname, h->Port); } } } @@ -1251,7 +1251,7 @@ void MakeSafeLogStr(char *str) } if (str[0] == 'h' && str[1] == 't' && str[2] == 't' && str[3] == 'p' && - ((str[4] == 's' && str[5] == ':') || (str[4] == ':'))) + ((str[4] == 's' && str[5] == ':') || (str[4] == ':'))) { is_http = true; } @@ -1259,7 +1259,7 @@ void MakeSafeLogStr(char *str) EnPrintableAsciiStr(str, '?'); len = StrLen(str); - for (i = 0;i < len;i++) + for (i = 0; i < len; i++) { if (str[i] == ',') { @@ -1284,6 +1284,7 @@ char *PacketLogParseProc(RECORD *rec) TOKEN_LIST *t; char tmp[MAX_SIZE]; bool tcp_conn; + UINT i; // Validate arguments if (rec == NULL) { @@ -1340,9 +1341,9 @@ char *PacketLogParseProc(RECORD *rec) // ARP request packet t->Token[7] = CopyStr("Request"); if (Endian16(p->L3.ARPv4Header->HardwareType) == ARP_HARDWARE_TYPE_ETHERNET && - p->L3.ARPv4Header->HardwareSize == 6 && - Endian16(p->L3.ARPv4Header->ProtocolType) == MAC_PROTO_IPV4 && - p->L3.ARPv4Header->ProtocolSize == 4) + p->L3.ARPv4Header->HardwareSize == 6 && + Endian16(p->L3.ARPv4Header->ProtocolType) == MAC_PROTO_IPV4 && + p->L3.ARPv4Header->ProtocolSize == 4) { char src_mac[16]; char src_ip[16]; @@ -1355,7 +1356,7 @@ char *PacketLogParseProc(RECORD *rec) IPToStr(src_ip, sizeof(src_ip), &src_ip_st); IPToStr(dst_ip, sizeof(dst_ip), &dst_ip_st); snprintf(tmp, sizeof(tmp), "Who has %s? Please Tell %s(%s)", - dst_ip, src_mac, src_ip); + dst_ip, src_mac, src_ip); t->Token[14] = CopyStr(tmp); } break; @@ -1364,9 +1365,9 @@ char *PacketLogParseProc(RECORD *rec) // ARP response packet t->Token[7] = CopyStr("Response"); if (Endian16(p->L3.ARPv4Header->HardwareType) == ARP_HARDWARE_TYPE_ETHERNET && - p->L3.ARPv4Header->HardwareSize == 6 && - Endian16(p->L3.ARPv4Header->ProtocolType) == MAC_PROTO_IPV4 && - p->L3.ARPv4Header->ProtocolSize == 4) + p->L3.ARPv4Header->HardwareSize == 6 && + Endian16(p->L3.ARPv4Header->ProtocolType) == MAC_PROTO_IPV4 && + p->L3.ARPv4Header->ProtocolSize == 4) { char src_mac[16]; char src_ip[16]; @@ -1379,7 +1380,7 @@ char *PacketLogParseProc(RECORD *rec) IPToStr(src_ip, sizeof(src_ip), &src_ip_st); IPToStr(dst_ip, sizeof(dst_ip), &dst_ip_st); snprintf(tmp, sizeof(tmp), "%s has %s", - src_mac, src_ip); + src_mac, src_ip); t->Token[14] = CopyStr(tmp); } break; @@ -1483,9 +1484,9 @@ char *PacketLogParseProc(RECORD *rec) IPToStr32(ip4, sizeof(ip4), p->L7.DHCPv4Header->RelayIP); snprintf(tmp, sizeof(tmp), - "TransactionId=%u ClientIP=%s YourIP=%s ServerIP=%s RelayIP=%s", - Endian32(p->L7.DHCPv4Header->TransactionId), - ip1, ip2, ip3, ip4); + "TransactionId=%u ClientIP=%s YourIP=%s ServerIP=%s RelayIP=%s", + Endian32(p->L7.DHCPv4Header->TransactionId), + ip1, ip2, ip3, ip4); t->Token[14] = CopyStr(tmp); } @@ -1514,26 +1515,26 @@ char *PacketLogParseProc(RECORD *rec) { Format(tmp, sizeof(tmp), "InitiatorCookie=%I64u ResponderCookie=%I64u " - "Version=0x%x ExchangeType=0x%x Flag=0x%x MessageId=%u MessageSize=%u", - Endian64(p->L7.IkeHeader->InitiatorCookie), - Endian64(p->L7.IkeHeader->ResponderCookie), - p->L7.IkeHeader->Version, - p->L7.IkeHeader->ExchangeType, - p->L7.IkeHeader->Flag, - Endian32(p->L7.IkeHeader->MessageId), - Endian32(p->L7.IkeHeader->MessageSize)); + "Version=0x%x ExchangeType=0x%x Flag=0x%x MessageId=%u MessageSize=%u", + Endian64(p->L7.IkeHeader->InitiatorCookie), + Endian64(p->L7.IkeHeader->ResponderCookie), + p->L7.IkeHeader->Version, + p->L7.IkeHeader->ExchangeType, + p->L7.IkeHeader->Flag, + Endian32(p->L7.IkeHeader->MessageId), + Endian32(p->L7.IkeHeader->MessageSize)); t->Token[14] = CopyStr(tmp); } } break; - - case L7_DNS: - // DNS query - t->Token[6] = CopyStr("DNSv4"); - t->Token[7] = CopyStr("DNS_Query"); - t->Token[14] = CopyStr(p->DnsQueryHost); - break; + + case L7_DNS: + // DNS query + t->Token[6] = CopyStr("DNSv4"); + t->Token[7] = CopyStr("DNS_Query"); + t->Token[14] = CopyStr(p->DnsQueryHost); + break; default: // Unknown Packet @@ -1570,145 +1571,152 @@ char *PacketLogParseProc(RECORD *rec) switch (p->TypeL4) { case L4_ICMPV6: + { + char info[MAX_SIZE]; + ICMPV6_HEADER_INFO *icmp = &p->ICMPv6HeaderPacketInfo; + ICMPV6_OPTION_LIST *ol = &icmp->OptionList; + + Zero(info, sizeof(info)); + + // ICMPv6 packet + t->Token[6] = CopyStr("ICMPv6"); + + switch (icmp->Type) { - char info[MAX_SIZE]; - ICMPV6_HEADER_INFO *icmp = &p->ICMPv6HeaderPacketInfo; - ICMPV6_OPTION_LIST *ol = &icmp->OptionList; + case ICMPV6_TYPE_ECHO_REQUEST: + // Echo request + t->Token[7] = CopyStr("Echo Request"); + snprintf(tmp, sizeof(tmp), "EchoDataSize=%u ", icmp->EchoDataSize); + StrCat(info, sizeof(info), tmp); + break; - Zero(info, sizeof(info)); + case ICMPV6_TYPE_ECHO_RESPONSE: + // Echo response + t->Token[7] = CopyStr("Echo Reply"); + snprintf(tmp, sizeof(tmp), "EchoDataSize=%u ", icmp->EchoDataSize); + StrCat(info, sizeof(info), tmp); + break; - // ICMPv6 packet - t->Token[6] = CopyStr("ICMPv6"); + case ICMPV6_TYPE_ROUTER_SOLICIATION: + { + ICMPV6_ROUTER_SOLICIATION_HEADER *h = icmp->Headers.RouterSoliciationHeader; + // Router Solicitation + t->Token[7] = CopyStr("Router Soliciation"); - switch (icmp->Type) + if (h != NULL) { - case ICMPV6_TYPE_ECHO_REQUEST: - // Echo request - t->Token[7] = CopyStr("Echo Request"); - snprintf(tmp, sizeof(tmp), "EchoDataSize=%u ", icmp->EchoDataSize); - StrCat(info, sizeof(info), tmp); - break; - - case ICMPV6_TYPE_ECHO_RESPONSE: - // Echo response - t->Token[7] = CopyStr("Echo Reply"); - snprintf(tmp, sizeof(tmp), "EchoDataSize=%u ", icmp->EchoDataSize); - StrCat(info, sizeof(info), tmp); - break; - - case ICMPV6_TYPE_ROUTER_SOLICIATION: - { - ICMPV6_ROUTER_SOLICIATION_HEADER *h = icmp->Headers.RouterSoliciationHeader; - // Router Solicitation - t->Token[7] = CopyStr("Router Soliciation"); - - if (h != NULL) - { - // No additional information - } - } - break; - - case ICMPV6_TYPE_ROUTER_ADVERTISEMENT: - { - ICMPV6_ROUTER_ADVERTISEMENT_HEADER *h = icmp->Headers.RouterAdvertisementHeader; - // Router Advertisement - t->Token[7] = CopyStr("Router Advertisement"); - - if (h != NULL) - { - snprintf(tmp, sizeof(tmp), "CurHopLimit=%u " - "Flags=0x%02X Lifetime=%u ", - h->CurHopLimit, h->Flags, Endian16(h->Lifetime)); - StrCat(info, sizeof(info), tmp); - } - } - break; - - case ICMPV6_TYPE_NEIGHBOR_SOLICIATION: - { - ICMPV6_NEIGHBOR_SOLICIATION_HEADER *h = icmp->Headers.NeighborSoliciationHeader; - // Neighbor Solicitation - t->Token[7] = CopyStr("Neighbor Soliciation"); - - if (h != NULL) - { - char tmp2[MAX_SIZE]; - - IP6AddrToStr(tmp2, sizeof(tmp2), &h->TargetAddress); - - snprintf(tmp, sizeof(tmp), "TargetAddress=%s ", - tmp2); - StrCat(info, sizeof(info), tmp); - } - } - break; - - case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: - { - ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER *h = icmp->Headers.NeighborAdvertisementHeader; - // Neighbor Advertisement - t->Token[7] = CopyStr("Neighbor Advertisement"); - - if (h != NULL) - { - char tmp2[MAX_SIZE]; - - IP6AddrToStr(tmp2, sizeof(tmp2), &h->TargetAddress); - - snprintf(tmp, sizeof(tmp), "TargetAddress=%s Flags=0x%02X ", - tmp2, h->Flags); - StrCat(info, sizeof(info), tmp); - } - } - break; - - default: - { - snprintf(tmp, sizeof(tmp), "Type=%u", icmp->Type); - t->Token[7] = CopyStr(tmp); - } - break; - } - - // Option data - if (ol->SourceLinkLayer != NULL) - { - char tmp2[MAX_SIZE]; - BinToStr(tmp2, sizeof(tmp2), ol->SourceLinkLayer->Address, 6); - snprintf(tmp, sizeof(tmp), "SourceLinkLayer=%s ", tmp2); - StrCat(info, sizeof(info), tmp); - } - if (ol->TargetLinkLayer != NULL) - { - char tmp2[MAX_SIZE]; - BinToStr(tmp2, sizeof(tmp2), ol->TargetLinkLayer->Address, 6); - snprintf(tmp, sizeof(tmp), "TargetLinkLayer=%s ", tmp2); - StrCat(info, sizeof(info), tmp); - } - if (ol->Prefix != NULL) - { - char tmp2[MAX_SIZE]; - IP6AddrToStr(tmp2, sizeof(tmp2), &ol->Prefix->Prefix); - snprintf(tmp, sizeof(tmp), "Prefix=%s/%u PrefixFlag=0x%02X ", tmp2, - ol->Prefix->SubnetLength, ol->Prefix->Flags); - StrCat(info, sizeof(info), tmp); - } - if (ol->Mtu != NULL) - { - snprintf(tmp, sizeof(tmp), "Mtu=%u ", Endian32(ol->Mtu->Mtu)); - StrCat(info, sizeof(info), tmp); - } - - Trim(info); - - if (IsEmptyStr(info) == false) - { - t->Token[14] = CopyStr(info); + // No additional information } } break; + case ICMPV6_TYPE_ROUTER_ADVERTISEMENT: + { + ICMPV6_ROUTER_ADVERTISEMENT_HEADER *h = icmp->Headers.RouterAdvertisementHeader; + // Router Advertisement + t->Token[7] = CopyStr("Router Advertisement"); + + if (h != NULL) + { + snprintf(tmp, sizeof(tmp), "CurHopLimit=%u " + "Flags=0x%02X Lifetime=%u ", + h->CurHopLimit, h->Flags, Endian16(h->Lifetime)); + StrCat(info, sizeof(info), tmp); + } + } + break; + + case ICMPV6_TYPE_NEIGHBOR_SOLICIATION: + { + ICMPV6_NEIGHBOR_SOLICIATION_HEADER *h = icmp->Headers.NeighborSoliciationHeader; + // Neighbor Solicitation + t->Token[7] = CopyStr("Neighbor Soliciation"); + + if (h != NULL) + { + char tmp2[MAX_SIZE]; + + IP6AddrToStr(tmp2, sizeof(tmp2), &h->TargetAddress); + + snprintf(tmp, sizeof(tmp), "TargetAddress=%s ", + tmp2); + StrCat(info, sizeof(info), tmp); + } + } + break; + + case ICMPV6_TYPE_NEIGHBOR_ADVERTISEMENT: + { + ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER *h = icmp->Headers.NeighborAdvertisementHeader; + // Neighbor Advertisement + t->Token[7] = CopyStr("Neighbor Advertisement"); + + if (h != NULL) + { + char tmp2[MAX_SIZE]; + + IP6AddrToStr(tmp2, sizeof(tmp2), &h->TargetAddress); + + snprintf(tmp, sizeof(tmp), "TargetAddress=%s Flags=0x%02X ", + tmp2, h->Flags); + StrCat(info, sizeof(info), tmp); + } + } + break; + + default: + { + snprintf(tmp, sizeof(tmp), "Type=%u", icmp->Type); + t->Token[7] = CopyStr(tmp); + } + break; + } + + // Option data + if (ol->SourceLinkLayer != NULL) + { + char tmp2[MAX_SIZE]; + BinToStr(tmp2, sizeof(tmp2), ol->SourceLinkLayer->Address, 6); + snprintf(tmp, sizeof(tmp), "SourceLinkLayer=%s ", tmp2); + StrCat(info, sizeof(info), tmp); + } + if (ol->TargetLinkLayer != NULL) + { + char tmp2[MAX_SIZE]; + BinToStr(tmp2, sizeof(tmp2), ol->TargetLinkLayer->Address, 6); + snprintf(tmp, sizeof(tmp), "TargetLinkLayer=%s ", tmp2); + StrCat(info, sizeof(info), tmp); + } + for (i = 0; i < ICMPV6_OPTION_PREFIXES_MAX_COUNT; i++) + { + if (ol->Prefix[i] != NULL) + { + char tmp2[MAX_SIZE]; + IP6AddrToStr(tmp2, sizeof(tmp2), &ol->Prefix[i]->Prefix); + snprintf(tmp, sizeof(tmp), "Prefix=%s/%u PrefixFlag=0x%02X ", tmp2, + ol->Prefix[i]->SubnetLength, ol->Prefix[i]->Flags); + StrCat(info, sizeof(info), tmp); + } + else + { + break; + } + } + if (ol->Mtu != NULL) + { + snprintf(tmp, sizeof(tmp), "Mtu=%u ", Endian32(ol->Mtu->Mtu)); + StrCat(info, sizeof(info), tmp); + } + + Trim(info); + + if (IsEmptyStr(info) == false) + { + t->Token[14] = CopyStr(info); + } + } + break; + case L4_TCP: // TCP packet tcp_conn = false; @@ -1786,26 +1794,26 @@ char *PacketLogParseProc(RECORD *rec) { Format(tmp, sizeof(tmp), "InitiatorCookie=%I64u ResponderCookie=%I64u " - "Version=0x%x ExchangeType=0x%x Flag=0x%x MessageId=%u MessageSize=%u", - Endian64(p->L7.IkeHeader->InitiatorCookie), - Endian64(p->L7.IkeHeader->ResponderCookie), - p->L7.IkeHeader->Version, - p->L7.IkeHeader->ExchangeType, - p->L7.IkeHeader->Flag, - Endian32(p->L7.IkeHeader->MessageId), - Endian32(p->L7.IkeHeader->MessageSize)); + "Version=0x%x ExchangeType=0x%x Flag=0x%x MessageId=%u MessageSize=%u", + Endian64(p->L7.IkeHeader->InitiatorCookie), + Endian64(p->L7.IkeHeader->ResponderCookie), + p->L7.IkeHeader->Version, + p->L7.IkeHeader->ExchangeType, + p->L7.IkeHeader->Flag, + Endian32(p->L7.IkeHeader->MessageId), + Endian32(p->L7.IkeHeader->MessageSize)); t->Token[14] = CopyStr(tmp); } } break; - - case L7_DNS: - // DNS query - t->Token[6] = CopyStr("DNSv6"); - t->Token[7] = CopyStr("DNS_Query"); - t->Token[14] = CopyStr(p->DnsQueryHost); - break; + + case L7_DNS: + // DNS query + t->Token[6] = CopyStr("DNSv6"); + t->Token[7] = CopyStr("DNS_Query"); + t->Token[14] = CopyStr(p->DnsQueryHost); + break; default: t->Token[6] = CopyStr("UDPv6"); @@ -1975,7 +1983,7 @@ char *GenCsvLine(TOKEN_LIST *t) } b = NewBuf(); - for (i = 0;i < t->NumTokens;i++) + for (i = 0; i < t->NumTokens; i++) { if (t->Token[i] != NULL) { @@ -2019,7 +2027,7 @@ void ReplaceForCsv(char *str) len = StrLen(str); - for (i = 0;i < len;i++) + for (i = 0; i < len; i++) { // Convert the comma to underscore if (str[i] == ',') @@ -2154,7 +2162,7 @@ void MakeLogFileNameStringFromTick(LOG *g, char *str, UINT size, UINT64 tick, UI if (g->CacheFlag) { if (g->LastTick == tick && - g->LastSwitchType == switch_type) + g->LastSwitchType == switch_type) { StrCpy(str, size, g->LastStr); return; @@ -2168,12 +2176,12 @@ void MakeLogFileNameStringFromTick(LOG *g, char *str, UINT size, UINT64 tick, UI { case LOG_SWITCH_SECOND: // Secondly basis snprintf(str, size, "_%04u%02u%02u_%02u%02u%02u", - st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); + st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute, st.wSecond); break; case LOG_SWITCH_MINUTE: // Minutely basis snprintf(str, size, "_%04u%02u%02u_%02u%02u", - st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute); + st.wYear, st.wMonth, st.wDay, st.wHour, st.wMinute); break; case LOG_SWITCH_HOUR: // Hourly basis @@ -2271,9 +2279,9 @@ bool MakeLogFileName(LOG *g, char *name, UINT size, char *dir, char *prefix, UIN } snprintf(name, size, "%s%s%s%s%s.log", dir, - StrLen(dir) == 0 ? "" : "/", - prefix, tmp, tmp2 - ); + StrLen(dir) == 0 ? "" : "/", + prefix, tmp, tmp2 + ); return ret; } @@ -2533,7 +2541,7 @@ static bool LogThreadWriteGeneral(LOG *log_object, BUF *buffer, IO **io, bool *l LockLog(log_object); { *log_date_changed = MakeLogFileName(log_object, file_name, sizeof(file_name), - log_object->DirName, log_object->Prefix, rec->Tick, log_object->SwitchType, log_object->CurrentLogNumber, current_logfile_datename); + log_object->DirName, log_object->Prefix, rec->Tick, log_object->SwitchType, log_object->CurrentLogNumber, current_logfile_datename); if (*log_date_changed) { @@ -2541,12 +2549,12 @@ static bool LogThreadWriteGeneral(LOG *log_object, BUF *buffer, IO **io, bool *l log_object->CurrentLogNumber = 0; MakeLogFileName(log_object, file_name, sizeof(file_name), - log_object->DirName, log_object->Prefix, rec->Tick, log_object->SwitchType, 0, current_logfile_datename); - for (i = 0;;i++) + log_object->DirName, log_object->Prefix, rec->Tick, log_object->SwitchType, 0, current_logfile_datename); + for (i = 0;; i++) { char tmp[MAX_SIZE]; MakeLogFileName(log_object, tmp, sizeof(tmp), - log_object->DirName, log_object->Prefix, rec->Tick, log_object->SwitchType, i, current_logfile_datename); + log_object->DirName, log_object->Prefix, rec->Tick, log_object->SwitchType, i, current_logfile_datename); if (IsFileExists(tmp) == false) { @@ -2564,7 +2572,7 @@ static bool LogThreadWriteGeneral(LOG *log_object, BUF *buffer, IO **io, bool *l if (StrCmp(current_file_name, file_name) != 0) { // If a log file is currently opened and writing to another log - // file is needed for this time, write the contents of the + // file is needed for this time, write the contents of the //buffer and close the log file. Write the contents of the buffer if (*io != NULL) { diff --git a/src/Cedar/Proto_PPP.c b/src/Cedar/Proto_PPP.c index c7af4310..5af5f0b1 100644 --- a/src/Cedar/Proto_PPP.c +++ b/src/Cedar/Proto_PPP.c @@ -365,7 +365,7 @@ void PPPThread(THREAD *thread, void *param) PPPSendPacketEx(p, pp, true); FreePPPPacketEx(pp, true); - Free(b); + Free(b); // Not FreeBlock because freed in FreePPPPacketEx } } else @@ -396,7 +396,7 @@ void PPPThread(THREAD *thread, void *param) PPPSendPacketEx(p, pp, true); FreePPPPacketEx(pp, true); - Free(b); + Free(b); // Not FreeBlock because freed in FreePPPPacketEx } } else @@ -1961,7 +1961,7 @@ bool PPPProcessIPv6CPRequestPacket(PPP_SESSION *p, PPP_PACKET *pp) { UINT64 newValue = 0; UINT64 value = READ_UINT64(t->Data); - if (!IPCIPv6CheckExistingLinkLocal(p->Ipc, value)) + if (value != 0 && !IPCIPv6CheckExistingLinkLocal(p->Ipc, value)) { t->IsAccepted = true; p->Ipc->IPv6ClientEUI = value; diff --git a/src/Mayaqua/TcpIp.c b/src/Mayaqua/TcpIp.c index 36849716..66ea1188 100644 --- a/src/Mayaqua/TcpIp.c +++ b/src/Mayaqua/TcpIp.c @@ -1140,6 +1140,7 @@ void BuildICMPv6OptionValue(BUF *b, UCHAR type, void *header_pointer, UINT total BUF *BuildICMPv6Options(ICMPV6_OPTION_LIST *o) { BUF *b; + UINT i; // Validate arguments if (o == NULL) { @@ -1156,9 +1157,16 @@ BUF *BuildICMPv6Options(ICMPV6_OPTION_LIST *o) { BuildICMPv6OptionValue(b, ICMPV6_OPTION_TYPE_TARGET_LINK_LAYER, o->TargetLinkLayer, sizeof(ICMPV6_OPTION_LINK_LAYER)); } - if (o->Prefix != NULL) + for (i = 0; i < ICMPV6_OPTION_PREFIXES_MAX_COUNT; i++) { - BuildICMPv6OptionValue(b, ICMPV6_OPTION_TYPE_PREFIX, o->Prefix, sizeof(ICMPV6_OPTION_PREFIX)); + if (o->Prefix[i] != NULL) + { + BuildICMPv6OptionValue(b, ICMPV6_OPTION_TYPE_PREFIX, o->Prefix[i], sizeof(ICMPV6_OPTION_PREFIX)); + } + else + { + break; + } } if (o->Mtu != NULL) { @@ -2402,7 +2410,15 @@ bool ParseICMPv6Options(ICMPV6_OPTION_LIST *o, UCHAR *buf, UINT size) // Prefix Information if (header_total_size >= sizeof(ICMPV6_OPTION_PREFIX)) { - o->Prefix = (ICMPV6_OPTION_PREFIX *)header_pointer; + UINT i; + for (i = 0; i < ICMPV6_OPTION_PREFIXES_MAX_COUNT; i++) + { + if (o->Prefix[i] == NULL) + { + o->Prefix[i] = (ICMPV6_OPTION_PREFIX *)header_pointer; + break; + } + } } else { @@ -2556,6 +2572,7 @@ bool ParseICMPv6(PKT *p, UCHAR *buf, UINT size) // Release of the ICMPv6 options void FreeCloneICMPv6Options(ICMPV6_OPTION_LIST *o) { + UINT i; // Validate arguments if (o == NULL) { @@ -2564,13 +2581,19 @@ void FreeCloneICMPv6Options(ICMPV6_OPTION_LIST *o) Free(o->SourceLinkLayer); Free(o->TargetLinkLayer); - Free(o->Prefix); + + for (i = 0; i < ICMPV6_OPTION_PREFIXES_MAX_COUNT; i++) + { + Free(o->Prefix[i]); + o->Prefix[i] = NULL; + } Free(o->Mtu); } // Clone of the ICMPv6 options void CloneICMPv6Options(ICMPV6_OPTION_LIST *dst, ICMPV6_OPTION_LIST *src) { + UINT i; // Validate arguments if (dst == NULL || src == NULL) { @@ -2581,7 +2604,17 @@ void CloneICMPv6Options(ICMPV6_OPTION_LIST *dst, ICMPV6_OPTION_LIST *src) dst->SourceLinkLayer = Clone(src->SourceLinkLayer, sizeof(ICMPV6_OPTION_LINK_LAYER)); dst->TargetLinkLayer = Clone(src->TargetLinkLayer, sizeof(ICMPV6_OPTION_LINK_LAYER)); - dst->Prefix = Clone(src->Prefix, sizeof(ICMPV6_OPTION_PREFIX)); + for (i = 0; i < ICMPV6_OPTION_PREFIXES_MAX_COUNT; i++) + { + if (src->Prefix[i] != NULL) + { + dst->Prefix[i] = Clone(src->Prefix[i], sizeof(ICMPV6_OPTION_PREFIX)); + } + else + { + break; + } + } dst->Mtu = Clone(src->Mtu, sizeof(ICMPV6_OPTION_MTU)); } diff --git a/src/Mayaqua/TcpIp.h b/src/Mayaqua/TcpIp.h index 85f55c67..83a4db8e 100644 --- a/src/Mayaqua/TcpIp.h +++ b/src/Mayaqua/TcpIp.h @@ -399,12 +399,14 @@ struct ICMPV6_NEIGHBOR_ADVERTISEMENT_HEADER #define ICMPV6_NEIGHBOR_ADVERTISEMENT_FLAG_SOLICITED 0x40 // Solicited flag #define ICMPV6_NEIGHBOR_ADVERTISEMENT_FLAG_OVERWRITE 0x20 // Overwrite flag +#define ICMPV6_OPTION_PREFIXES_MAX_COUNT 10 + // ICMPv6 option list struct ICMPV6_OPTION_LIST { ICMPV6_OPTION_LINK_LAYER *SourceLinkLayer; // Source link-layer address ICMPV6_OPTION_LINK_LAYER *TargetLinkLayer; // Target link-layer address - ICMPV6_OPTION_PREFIX *Prefix; // Prefix Information + ICMPV6_OPTION_PREFIX *Prefix[ICMPV6_OPTION_PREFIXES_MAX_COUNT]; // Prefix Information - may be multiple in one request ICMPV6_OPTION_MTU *Mtu; // MTU } GCC_PACKED; From cbbac659a3a509c8107f2ce439d3d9ef75d126dd Mon Sep 17 00:00:00 2001 From: Evengard Date: Tue, 12 May 2020 18:51:55 +0300 Subject: [PATCH 6/6] Fixing VS2015 quirks --- src/Cedar/IPC.c | 16 ++++++++++------ 1 file changed, 10 insertions(+), 6 deletions(-) diff --git a/src/Cedar/IPC.c b/src/Cedar/IPC.c index e455c101..d910737d 100644 --- a/src/Cedar/IPC.c +++ b/src/Cedar/IPC.c @@ -2284,6 +2284,8 @@ UINT64 IPCIPv6GetServerEui(IPC *ipc) UCHAR destMacAddress[6]; IPV6_ADDR linkLocal; BUF *packet; + UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); + UINT64 timeout_retry = 0; Zero(&linkLocal, sizeof(IPV6_ADDR)); @@ -2304,9 +2306,6 @@ UINT64 IPCIPv6GetServerEui(IPC *ipc) packet = BuildICMPv6RouterSoliciation(&senderV6, &destV6, ipc->MacAddress, 0); - UINT64 giveup_time = Tick64() + (UINT64)(IPC_IPV6_RA_MAX_RETRIES * IPC_IPV6_RA_INTERVAL); - UINT64 timeout_retry = 0; - while (LIST_NUM(ipc->IPv6RouterAdvs) == 0) { UINT64 now = Tick64(); @@ -2570,6 +2569,11 @@ void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip) BUF *neighborSolicit; UCHAR destMacAddress[6]; IPV6_ADDR solicitAddress; + + CHAR tmp[MAX_SIZE]; + UCHAR *copy; + BLOCK *blk; + Zero(&solicitAddress, sizeof(IPV6_ADDR)); Copy(&solicitAddress.Value[13], &header->DestAddress.Value[13], 3); solicitAddress.Value[0] = 0xFF; @@ -2585,9 +2589,9 @@ void IPCIPv6SendUnicast(IPC *ipc, void *data, UINT size, IP *next_ip) FreeBuf(neighborSolicit); - CHAR tmp[MAX_SIZE]; - UCHAR *copy = Clone(data, size); - BLOCK *blk = NewBlock(copy, size, 0); + + copy = Clone(data, size); + blk = NewBlock(copy, size, 0); InsertQueue(ndtMatch->PacketQueue, blk); IPToStr6(tmp, MAX_SIZE, next_ip);