diff options
Diffstat (limited to 'src/Mayaqua/Network.c')
| -rw-r--r-- | src/Mayaqua/Network.c | 21774 |
1 files changed, 21774 insertions, 0 deletions
diff --git a/src/Mayaqua/Network.c b/src/Mayaqua/Network.c new file mode 100644 index 00000000..3025c5e3 --- /dev/null +++ b/src/Mayaqua/Network.c @@ -0,0 +1,21774 @@ +// SoftEther VPN Source Code
+// Mayaqua Kernel
+//
+// SoftEther VPN Server, Client and Bridge are free software under GPLv2.
+//
+// Copyright (c) 2012-2014 Daiyuu Nobori.
+// Copyright (c) 2012-2014 SoftEther VPN Project, University of Tsukuba, Japan.
+// Copyright (c) 2012-2014 SoftEther Corporation.
+//
+// All Rights Reserved.
+//
+// http://www.softether.org/
+//
+// Author: Daiyuu Nobori
+// Comments: Tetsuo Sugiyama, Ph.D.
+//
+//
+// This program is free software; you can redistribute it and/or
+// modify it under the terms of the GNU General Public License
+// version 2 as published by the Free Software Foundation.
+//
+// This program is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+// GNU General Public License for more details.
+//
+// You should have received a copy of the GNU General Public License version 2
+// along with this program; if not, write to the Free Software
+// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+// IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+// CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+// TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+// SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+//
+// THE LICENSE AGREEMENT IS ATTACHED ON THE SOURCE-CODE PACKAGE
+// AS "LICENSE.TXT" FILE. READ THE TEXT FILE IN ADVANCE TO USE THE SOFTWARE.
+//
+//
+// THIS SOFTWARE IS DEVELOPED IN JAPAN, AND DISTRIBUTED FROM JAPAN,
+// UNDER JAPANESE LAWS. YOU MUST AGREE IN ADVANCE TO USE, COPY, MODIFY,
+// MERGE, PUBLISH, DISTRIBUTE, SUBLICENSE, AND/OR SELL COPIES OF THIS
+// SOFTWARE, THAT ANY JURIDICAL DISPUTES WHICH ARE CONCERNED TO THIS
+// SOFTWARE OR ITS CONTENTS, AGAINST US (SOFTETHER PROJECT, SOFTETHER
+// CORPORATION, DAIYUU NOBORI OR OTHER SUPPLIERS), OR ANY JURIDICAL
+// DISPUTES AGAINST US WHICH ARE CAUSED BY ANY KIND OF USING, COPYING,
+// MODIFYING, MERGING, PUBLISHING, DISTRIBUTING, SUBLICENSING, AND/OR
+// SELLING COPIES OF THIS SOFTWARE SHALL BE REGARDED AS BE CONSTRUED AND
+// CONTROLLED BY JAPANESE LAWS, AND YOU MUST FURTHER CONSENT TO
+// EXCLUSIVE JURISDICTION AND VENUE IN THE COURTS SITTING IN TOKYO,
+// JAPAN. YOU MUST WAIVE ALL DEFENSES OF LACK OF PERSONAL JURISDICTION
+// AND FORUM NON CONVENIENS. PROCESS MAY BE SERVED ON EITHER PARTY IN
+// THE MANNER AUTHORIZED BY APPLICABLE LAW OR COURT RULE.
+//
+// USE ONLY IN JAPAN. DO NOT USE IT IN OTHER COUNTRIES. IMPORTING THIS
+// SOFTWARE INTO OTHER COUNTRIES IS AT YOUR OWN RISK. SOME COUNTRIES
+// PROHIBIT ENCRYPTED COMMUNICATIONS. USING THIS SOFTWARE IN OTHER
+// COUNTRIES MIGHT BE RESTRICTED.
+//
+//
+// DEAR SECURITY EXPERTS
+// ---------------------
+//
+// If you find a bug or a security vulnerability please kindly inform us
+// about the problem immediately so that we can fix the security problem
+// to protect a lot of users around the world as soon as possible.
+//
+// Our e-mail address for security reports is:
+// softether-vpn-security [at] softether.org
+//
+// Please note that the above e-mail address is not a technical support
+// inquiry address. If you need technical assistance, please visit
+// http://www.softether.org/ and ask your question on the users forum.
+//
+// Thank you for your cooperation.
+
+
+// Network.c
+// Network communication module
+
+#include <GlobalConst.h>
+
+#define ENCRYPT_C
+#define NETWORK_C
+
+#define __WINCRYPT_H__
+
+#ifdef WIN32
+// Include windows.h for Socket API
+#define _WIN32_WINNT 0x0502
+#define WINVER 0x0502
+#include <Ws2tcpip.h>
+#include <Wspiapi.h>
+#include <winsock2.h>
+#include <windows.h>
+#include <Iphlpapi.h>
+#include <ws2ipdef.h>
+#include <netioapi.h>
+#include <Icmpapi.h>
+#endif // WIN32
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <wchar.h>
+#include <stdarg.h>
+#include <time.h>
+#include <openssl/ssl.h>
+#include <openssl/err.h>
+#include <openssl/rand.h>
+#include <openssl/engine.h>
+#include <openssl/bio.h>
+#include <openssl/x509.h>
+#include <openssl/pkcs7.h>
+#include <openssl/pkcs12.h>
+#include <openssl/rc4.h>
+#include <openssl/md5.h>
+#include <openssl/sha.h>
+#include <Mayaqua/Mayaqua.h>
+
+#ifdef OS_WIN32
+NETWORK_WIN32_FUNCTIONS *w32net;
+struct ROUTE_CHANGE_DATA
+{
+ OVERLAPPED Overlapped;
+ HANDLE Handle;
+ UINT NumCalled;
+};
+#endif // OS_WIN32
+
+// Whether the blocking occurs in SSL
+#if defined(UNIX_BSD)
+#define FIX_SSL_BLOCKING
+#endif
+
+// IPV6_V6ONLY constant
+#ifdef UNIX_LINUX
+#ifndef IPV6_V6ONLY
+#define IPV6_V6ONLY 26
+#endif // IPV6_V6ONLY
+#endif // UNIX_LINUX
+
+#ifdef UNIX_SOLARIS
+#ifndef IPV6_V6ONLY
+#define IPV6_V6ONLY 0x27
+#endif // IPV6_V6ONLY
+#endif // UNIX_SOLARIS
+
+
+
+// HTTP constant
+static char http_404_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>404 Not Found</TITLE>\r\n</HEAD><BODY>\r\n<H1>Not Found</H1>\r\nThe requested URL $TARGET$ was not found on this server.<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
+static char http_403_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>403 Forbidden</TITLE>\r\n</HEAD><BODY>\r\n<H1>Forbidden</H1>\r\nYou don't have permission to access $TARGET$\r\non this server.<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
+static char http_500_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>500 Server Error</TITLE>\r\n</HEAD><BODY>\r\n<H1>Server Error</H1>\r\nServer Error<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
+static char http_501_str[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>501 Method Not Implemented</TITLE>\r\n</HEAD><BODY>\r\n<H1>Method Not Implemented</H1>\r\n$METHOD$ to $TARGET$ not supported.<P>\r\nInvalid method in request $METHOD$ $TARGET$ $VERSION$<P>\r\n<HR>\r\n<ADDRESS>HTTP Server at $HOST$ Port $PORT$</ADDRESS>\r\n</BODY></HTML>\r\n";
+static char http_detect_server_startwith[] = "<!DOCTYPE HTML PUBLIC \"-//IETF//DTD HTML 2.0//EN\">\r\n<HTML><HEAD>\r\n<TITLE>403 Forbidden</TITLE>\r\n</HEAD><BODY>\r\n<H1>Forbidden</H1>\r\nYou don't have permission to access ";
+static char http_detect_server_tag_future[] = "9C37197CA7C2428388C2E6E59B829B30";
+
+// DNS cache list
+static LIST *DnsCache;
+
+// Lock related
+static LOCK *machine_name_lock = NULL;
+static LOCK *disconnect_function_lock = NULL;
+static LOCK *aho = NULL;
+static LOCK *socket_library_lock = NULL;
+extern LOCK *openssl_lock;
+static LOCK *ssl_accept_lock = NULL;
+static LOCK *ssl_connect_lock = NULL;
+static TOKEN_LIST *cipher_list_token = NULL;
+static COUNTER *num_tcp_connections = NULL;
+static LOCK *dns_lock = NULL;
+static LOCK *unix_dns_server_addr_lock = NULL;
+static IP unix_dns_server;
+static LIST *HostCacheList = NULL;
+static LIST *WaitThreadList = NULL;
+static bool disable_cache = false;
+static bool NetworkReleaseMode = false; // Network release mode
+static UCHAR machine_ip_process_hash[SHA1_SIZE];
+static LOCK *machine_ip_process_hash_lock = NULL;
+static LOCK *current_global_ip_lock = NULL;
+static LOCK *current_fqdn_lock = NULL;
+static bool current_global_ip_set = false;
+static IP current_glocal_ipv4 = {0};
+static IP current_glocal_ipv6 = {0};
+static char current_fqdn[MAX_SIZE];
+static bool g_no_rudp_server = false;
+static bool g_no_rudp_register = false;
+static bool g_natt_low_priority = false;
+static LOCK *host_ip_address_list_cache_lock = NULL;
+static UINT64 host_ip_address_list_cache_last = 0;
+static LIST *host_ip_address_cache = NULL;
+
+
+static char *cipher_list = "RC4-MD5 RC4-SHA AES128-SHA AES256-SHA DES-CBC-SHA DES-CBC3-SHA";
+static LIST *ip_clients = NULL;
+
+static LIST *local_mac_list = NULL;
+static LOCK *local_mac_list_lock = NULL;
+
+static UINT rand_port_numbers[256] = {0};
+
+
+static bool g_use_privateip_file = false;
+
+typedef struct PRIVATE_IP_SUBNET
+{
+ UINT Ip, Mask, Ip2;
+} PRIVATE_IP_SUBNET;
+
+static LIST *g_private_ip_list = NULL;
+
+
+static LIST *g_dyn_value_list = NULL;
+
+
+//#define RUDP_DETAIL_LOG
+
+
+
+
+// Get a value from a dynamic value list (Returns a default value if the value is not found)
+UINT64 GetDynValueOrDefault(char *name, UINT64 default_value, UINT64 min_value, UINT64 max_value)
+{
+ UINT64 ret = GetDynValue(name);
+
+ if (ret == 0)
+ {
+ return default_value;
+ }
+
+ if (ret < min_value)
+ {
+ ret = min_value;
+ }
+
+ if (ret > max_value)
+ {
+ ret = max_value;
+ }
+
+ return ret;
+}
+
+// Get a value from a dynamic value list (Returns a default value if the value is not found)
+// The value is limited to 1/5 to 50 times of the default value for safety
+UINT64 GetDynValueOrDefaultSafe(char *name, UINT64 default_value)
+{
+ return GetDynValueOrDefault(name, default_value, default_value / (UINT64)5, default_value * (UINT64)50);
+}
+
+// Get a value from a dynamic value list
+UINT64 GetDynValue(char *name)
+{
+ UINT64 ret = 0;
+ // Validate arguments
+ if (name == NULL)
+ {
+ return 0;
+ }
+
+ if (g_dyn_value_list == NULL)
+ {
+ return 0;
+ }
+
+ LockList(g_dyn_value_list);
+ {
+ UINT i;
+
+ for (i = 0; i < LIST_NUM(g_dyn_value_list);i++)
+ {
+ DYN_VALUE *vv = LIST_DATA(g_dyn_value_list, i);
+
+ if (StrCmpi(vv->Name, name) == 0)
+ {
+ ret = vv->Value;
+ break;
+ }
+ }
+ }
+ UnlockList(g_dyn_value_list);
+
+ return ret;
+}
+
+// Set the value to the dynamic value list
+void SetDynListValue(char *name, UINT64 value)
+{
+ // Validate arguments
+ if (name == NULL)
+ {
+ return;
+ }
+
+ if (g_dyn_value_list == NULL)
+ {
+ return;
+ }
+
+ LockList(g_dyn_value_list);
+ {
+ UINT i;
+ DYN_VALUE *v = NULL;
+
+ for (i = 0; i < LIST_NUM(g_dyn_value_list);i++)
+ {
+ DYN_VALUE *vv = LIST_DATA(g_dyn_value_list, i);
+
+ if (StrCmpi(vv->Name, name) == 0)
+ {
+ v = vv;
+ break;
+ }
+ }
+
+ if (v == NULL)
+ {
+ v = ZeroMalloc(sizeof(DYN_VALUE));
+ StrCpy(v->Name, sizeof(v->Name), name);
+
+ Add(g_dyn_value_list, v);
+ }
+
+ v->Value = value;
+ }
+ UnlockList(g_dyn_value_list);
+}
+
+// Apply by extracting dynamic value list from the specified PACK
+void ExtractAndApplyDynList(PACK *p)
+{
+ BUF *b;
+ // Validate arguments
+ if (p == NULL)
+ {
+ return;
+ }
+
+ b = PackGetBuf(p, "DynList");
+ if (b == NULL)
+ {
+ return;
+ }
+
+ AddDynList(b);
+
+ FreeBuf(b);
+}
+
+// Insert the data to the dynamic value list
+void AddDynList(BUF *b)
+{
+ PACK *p;
+ TOKEN_LIST *t;
+ // Validate arguments
+ if (b == NULL)
+ {
+ return;
+ }
+
+ SeekBufToBegin(b);
+
+ p = BufToPack(b);
+ if (p == NULL)
+ {
+ return;
+ }
+
+ t = GetPackElementNames(p);
+ if (t != NULL)
+ {
+ UINT i;
+
+ for (i = 0;i < t->NumTokens;i++)
+ {
+ char *name = t->Token[i];
+ UINT64 v = PackGetInt64(p, name);
+
+ SetDynListValue(name, v);
+ }
+
+ FreeToken(t);
+ }
+
+ FreePack(p);
+}
+
+// Initialization of the dynamic value list
+void InitDynList()
+{
+ g_dyn_value_list = NewList(NULL);
+}
+
+// Solution of dynamic value list
+void FreeDynList()
+{
+ UINT i;
+ if (g_dyn_value_list == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(g_dyn_value_list);i++)
+ {
+ DYN_VALUE *d = LIST_DATA(g_dyn_value_list, i);
+
+ Free(d);
+ }
+
+ ReleaseList(g_dyn_value_list);
+
+ g_dyn_value_list = NULL;
+}
+
+// Check whether the string in the string list appears in the specified string
+bool IsInStrByStrList(char *str, char *str_list)
+{
+ TOKEN_LIST *t;
+ bool ret = false;
+ // Validate arguments
+ if (str == NULL || str_list == NULL)
+ {
+ return false;
+ }
+
+ t = ParseTokenWithoutNullStr(str_list, ", \t\r\n");
+ if (t != NULL)
+ {
+ UINT i;
+
+ for (i = 0;i < t->NumTokens;i++)
+ {
+ char *s = t->Token[i];
+
+ if (StrLen(s) >= 1)
+ {
+ if (InStrEx(str, s, true))
+ {
+ ret = true;
+ break;
+ }
+ }
+ }
+ }
+
+ FreeToken(t);
+
+ return ret;
+}
+
+
+// Search whether the IP address exists on the IP address list string
+bool IsIpInStrList(IP *ip, char *ip_list)
+{
+ char ip_str[128];
+ TOKEN_LIST *t;
+ bool ret = false;
+ // Validate arguments
+ if (ip == NULL || ip_list == NULL)
+ {
+ return false;
+ }
+
+ Zero(ip_str, sizeof(ip_str));
+ IPToStr(ip_str, sizeof(ip_str), ip);
+
+ t = ParseTokenWithoutNullStr(ip_list, ", \t\r\n");
+
+ if (t != NULL)
+ {
+ UINT i;
+
+ for (i = 0;i < t->NumTokens;i++)
+ {
+ char *s = t->Token[i];
+
+ if (StrCmpi(s, ip_str) == 0)
+ {
+ ret = true;
+ break;
+ }
+ }
+ }
+
+ FreeToken(t);
+
+ return ret;
+}
+
+
+// Disable NAT-T function globally
+void DisableRDUPServerGlobally()
+{
+ g_no_rudp_server = true;
+}
+
+// Disable NAT-T registration globally
+void DisableRUDPRegisterGlobally()
+{
+ g_no_rudp_register = true;
+}
+
+// Lower the priority of the host at NAT-T
+void SetNatTLowPriority()
+{
+ g_natt_low_priority = true;
+}
+
+// Extract only the host name part from FQDN
+void GetSimpleHostname(char *hostname, UINT hostname_size, char *fqdn)
+{
+ UINT i;
+ ClearStr(hostname, hostname_size);
+ // Validate arguments
+ if (hostname == NULL || fqdn == NULL)
+ {
+ return;
+ }
+
+ StrCpy(hostname, hostname_size, fqdn);
+ Trim(hostname);
+
+ i = SearchStrEx(hostname, ".", 0, true);
+ if (i != INFINITE)
+ {
+ hostname[i] = 0;
+ }
+}
+
+// Get the current time zone
+int GetCurrentTimezone()
+{
+ int ret = 0;
+
+#ifdef OS_WIN32
+ ret = GetCurrentTimezoneWin32();
+#else // OS_WIN32
+ {
+#if defined(UNIX_MACOS) || defined(UNIX_BSD)
+ struct timeval tv;
+ struct timezone tz;
+
+ Zero(&tv, sizeof(tv));
+ Zero(&tz, sizeof(tz));
+
+ gettimeofday(&tv, &tz);
+
+ ret = tz.tz_minuteswest;
+
+#else // defined(UNIX_MACOS) || defined(UNIX_BSD)
+ tzset();
+
+ ret = timezone / 60;
+#endif // defined(UNIX_MACOS) || defined(UNIX_BSD)
+ }
+#endif // OS_WIN32
+
+ return ret;
+}
+
+// Flag of whether to use the DNS proxy
+bool IsUseDnsProxy()
+{
+ return false;
+}
+
+// Flag of whether to use an alternate host name
+bool IsUseAlternativeHostname()
+{
+ return IsUseDnsProxy();
+}
+
+#ifdef OS_WIN32
+// Get the current time zone (Win32)
+int GetCurrentTimezoneWin32()
+{
+ TIME_ZONE_INFORMATION info;
+ Zero(&info, sizeof(info));
+
+ if (GetTimeZoneInformation(&info) == TIME_ZONE_ID_INVALID)
+ {
+ return 0;
+ }
+
+ return info.Bias;
+}
+#endif // OS_WIN32
+
+
+// Set the current FQDN of the DDNS
+void SetCurrentDDnsFqdn(char *name)
+{
+ // Validate arguments
+ if (name == NULL)
+ {
+ return;
+ }
+
+ Lock(current_fqdn_lock);
+ {
+ StrCpy(current_fqdn, sizeof(current_fqdn), name);
+ }
+ Unlock(current_fqdn_lock);
+}
+
+// Get the current DDNS FQDN hash
+UINT GetCurrentDDnsFqdnHash()
+{
+ UINT ret;
+ UCHAR hash[SHA1_SIZE];
+ char name[MAX_SIZE];
+
+ ClearStr(name, sizeof(name));
+ GetCurrentDDnsFqdn(name, sizeof(name));
+
+ Trim(name);
+ StrUpper(name);
+
+ HashSha1(hash, name, StrLen(name));
+
+ Copy(&ret, hash, sizeof(UINT));
+
+ return ret;
+}
+
+// Get the current DDNS FQDN
+void GetCurrentDDnsFqdn(char *name, UINT size)
+{
+ ClearStr(name, size);
+ // Validate arguments
+ if (name == NULL || size == 0)
+ {
+ return;
+ }
+
+ Lock(current_fqdn_lock);
+ {
+ StrCpy(name, size, current_fqdn);
+ }
+ Unlock(current_fqdn_lock);
+
+ Trim(name);
+}
+
+// Check whether the specified MAC address exists on the local host (high speed)
+bool IsMacAddressLocalFast(void *addr)
+{
+ bool ret = false;
+ // Validate arguments
+ if (addr == NULL)
+ {
+ return false;
+ }
+
+ Lock(local_mac_list_lock);
+ {
+ if (local_mac_list == NULL)
+ {
+ // First enumeration
+ RefreshLocalMacAddressList();
+ }
+
+ ret = IsMacAddressLocalInner(local_mac_list, addr);
+ }
+ Unlock(local_mac_list_lock);
+
+ return ret;
+}
+
+// Update the local MAC address list
+void RefreshLocalMacAddressList()
+{
+ Lock(local_mac_list_lock);
+ {
+ if (local_mac_list != NULL)
+ {
+ FreeNicList(local_mac_list);
+ }
+
+ local_mac_list = GetNicList();
+ }
+ Unlock(local_mac_list_lock);
+}
+
+// Check whether the specified MAC address exists on the local host
+bool IsMacAddressLocal(void *addr)
+{
+ LIST *o;
+ bool ret;
+ // Validate arguments
+ if (addr == NULL)
+ {
+ return false;
+ }
+
+ o = GetNicList();
+
+ ret = IsMacAddressLocalInner(o, addr);
+
+ FreeNicList(o);
+
+ return ret;
+}
+bool IsMacAddressLocalInner(LIST *o, void *addr)
+{
+ bool ret = false;
+ UINT i;
+ // Validate arguments
+ if (o == NULL || addr == NULL)
+ {
+ return false;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ NIC_ENTRY *e = LIST_DATA(o, i);
+
+ if (Cmp(e->MacAddress, addr, 6) == 0)
+ {
+ ret = true;
+ break;
+ }
+ }
+
+ return ret;
+}
+
+// Get a list of the NICs on the computer
+LIST *GetNicList()
+{
+ LIST *o = NULL;
+
+#ifdef OS_WIN32
+ o = Win32GetNicList();
+#endif // OS_WIN32
+
+#ifdef UNIX_LINUX
+#endif // UNIX_LINUX
+
+ if (o == NULL)
+ {
+ return NewListFast(NULL);
+ }
+
+ return o;
+}
+
+#ifdef OS_WIN32
+LIST *Win32GetNicList()
+{
+ UINT i;
+ LIST *o = NewListFast(NULL);
+ MS_ADAPTER_LIST *al = MsCreateAdapterList();
+
+ if (al == NULL)
+ {
+ return NULL;
+ }
+
+ for (i = 0;i < al->Num;i++)
+ {
+ MS_ADAPTER *a = al->Adapters[i];
+
+ if (a->Type == 6 && a->AddressSize == 6)
+ {
+ NIC_ENTRY *e = ZeroMalloc(sizeof(NIC_ENTRY));
+
+ StrCpy(e->IfName, sizeof(e->IfName), a->Title);
+ Copy(e->MacAddress, a->Address, 6);
+
+ Add(o, e);
+ }
+ }
+
+ MsFreeAdapterList(al);
+
+ return o;
+}
+#endif // OS_WIN32
+
+// Release the NIC list
+void FreeNicList(LIST *o)
+{
+ UINT i;
+ // Validate arguments
+ if (o == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ NIC_ENTRY *e = LIST_DATA(o, i);
+
+ Free(e);
+ }
+
+ ReleaseList(o);
+}
+
+// If the computer is connected to the FLET'S line currently, detect the type of the line (obsolete)
+UINT DetectFletsType()
+{
+ UINT ret = 0;
+ //LIST *o = GetHostIPAddressList();
+// UINT i;
+
+/*
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *ip = LIST_DATA(o, i);
+
+ if (IsIP6(ip))
+ {
+ char ip_str[MAX_SIZE];
+
+ IPToStr(ip_str, sizeof(ip_str), ip);
+
+ 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);
+*/
+ return ret;
+}
+
+// Query for the IP address using the DNS proxy for the B FLETs
+bool GetIPViaDnsProxyForJapanFlets(IP *ip_ret, char *hostname, bool ipv6, UINT timeout, bool *cancel, char *dns_proxy_hostname)
+{
+ SOCK *s;
+ char connect_hostname[MAX_SIZE];
+ char connect_hostname2[MAX_SIZE];
+ IP dns_proxy_ip;
+ bool ret = false;
+ bool dummy_flag = false;
+ char request_str[512];
+ // Validate arguments
+ if (ip_ret == NULL || hostname == NULL)
+ {
+ return false;
+ }
+ if (timeout == 0)
+ {
+ timeout = BFLETS_DNS_PROXY_TIMEOUT_FOR_QUERY;
+ }
+ if (cancel == NULL)
+ {
+ cancel = &dummy_flag;
+ }
+
+ // Get the IP address of the DNS proxy server
+ if (IsEmptyStr(dns_proxy_hostname))
+ {
+ // B FLETs
+ if (GetDnsProxyIPAddressForJapanBFlets(&dns_proxy_ip, BFLETS_DNS_PROXY_TIMEOUT_FOR_GET_F, cancel) == false)
+ {
+ return false;
+ }
+ }
+ else
+ {
+ // FLET'S NEXT
+ if (GetIP4Ex6Ex2(&dns_proxy_ip, dns_proxy_hostname, FLETS_NGN_DNS_QUERY_TIMEOUT, true, cancel, true) == false)
+ {
+ return false;
+ }
+ }
+
+ if (*cancel)
+ {
+ return false;
+ }
+
+ IPToStr(connect_hostname, sizeof(connect_hostname), &dns_proxy_ip);
+
+ /*{
+ StrCpy(connect_hostname, sizeof(connect_hostname), "2409:250:62c0:100:6a05:caff:fe09:5158");
+ }*/
+
+ StrCpy(connect_hostname2, sizeof(connect_hostname2), connect_hostname);
+ if (IsIP6(&dns_proxy_ip))
+ {
+ Format(connect_hostname2, sizeof(connect_hostname2), "[%s]", connect_hostname);
+ }
+
+ s = ConnectEx3(connect_hostname, BFLETS_DNS_PROXY_PORT, timeout, cancel, NULL, NULL, false, false, false);
+
+ if (s == NULL)
+ {
+ return false;
+ }
+
+ if (*cancel)
+ {
+ Disconnect(s);
+ ReleaseSock(s);
+
+ return false;
+ }
+
+ SetTimeout(s, timeout);
+
+ // Start the SSL
+ if (StartSSLEx(s, NULL, NULL, true, 0, NULL) && (*cancel == false))
+ {
+ UCHAR hash[SHA1_SIZE];
+ BUF *hash2 = StrToBin(BFLETS_DNS_PROXY_CERT_HASH);
+
+ Zero(hash, sizeof(hash));
+ GetXDigest(s->RemoteX, hash, true);
+
+ if (Cmp(hash, hash2->Buf, SHA1_SIZE) == 0)
+ {
+ // 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);
+
+ if (SendAll(s, request_str, StrLen(request_str), true))
+ {
+ if (*cancel == false)
+ {
+ BUF *recv_buf = NewBuf();
+ UINT port_ret;
+
+ while (true)
+ {
+ UCHAR tmp[MAX_SIZE];
+ UINT r;
+
+ r = Recv(s, tmp, sizeof(tmp), true);
+
+ if (r == 0 || (recv_buf->Size > 65536))
+ {
+ break;
+ }
+ else
+ {
+ WriteBuf(recv_buf, tmp, r);
+ }
+ }
+
+ ret = RUDPParseIPAndPortStr(recv_buf->Buf, recv_buf->Size, ip_ret, &port_ret);
+
+ FreeBuf(recv_buf);
+ }
+ }
+ }
+
+ FreeBuf(hash2);
+ }
+
+ Disconnect(s);
+ ReleaseSock(s);
+
+ if (ret)
+ {
+ NewDnsCache(hostname, ip_ret);
+ }
+
+ return ret;
+}
+
+// Get the IP address of the available DNS proxy in B-FLET'S service that is provided by NTT East of Japan
+bool GetDnsProxyIPAddressForJapanBFlets(IP *ip_ret, UINT timeout, bool *cancel)
+{
+ BUF *b;
+ LIST *o;
+ bool ret = false;
+ // Validate arguments
+ if (ip_ret == NULL)
+ {
+ return false;
+ }
+ if (timeout == 0)
+ {
+ timeout = BFLETS_DNS_PROXY_TIMEOUT_FOR_GET_F;
+ }
+
+ b = QueryFileByUdpForJapanBFlets(timeout, cancel);
+
+ if (b == NULL)
+ {
+ return false;
+ }
+
+ o = ReadIni(b);
+
+ if (o != NULL)
+ {
+ INI_ENTRY *e = GetIniEntry(o, "DDnsServerForBFlets");
+
+ if (e != NULL)
+ {
+ char *s = e->Value;
+
+ if (IsEmptyStr(s) == false)
+ {
+ IP ip;
+
+ if (StrToIP(&ip, s))
+ {
+ if (IsZeroIp(&ip) == false)
+ {
+ Copy(ip_ret, &ip, sizeof(IP));
+ ret = true;
+ }
+ }
+ }
+ }
+ }
+
+ FreeIni(o);
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Get a valid F.txt file in B-FLET'S service that is provided by NTT East of Japan
+BUF *QueryFileByUdpForJapanBFlets(UINT timeout, bool *cancel)
+{
+ bool dummy_flag = false;
+ BUF *txt_buf = NULL;
+ BUF *ret = NULL;
+ LIST *ip_list = NULL;
+ UINT i;
+ // Validate arguments
+ if (cancel == NULL)
+ {
+ cancel = &dummy_flag;
+ }
+ if (timeout == 0)
+ {
+ timeout = BFLETS_DNS_PROXY_TIMEOUT_FOR_GET_F;
+ }
+
+ txt_buf = ReadDump(UDP_FILE_QUERY_BFLETS_TXT_FILENAME);
+ if (txt_buf == NULL)
+ {
+ return NULL;
+ }
+
+ ip_list = NewListFast(NULL);
+
+ while (true)
+ {
+ char *line = CfgReadNextLine(txt_buf);
+ if (line == NULL)
+ {
+ break;
+ }
+
+ Trim(line);
+
+ if (IsEmptyStr(line) == false && StartWith(line, "#") == false)
+ {
+ IP ip;
+
+ if (StrToIP6(&ip, line))
+ {
+ if (IsZeroIp(&ip) == false)
+ {
+ if (IsIPv6LocalNetworkAddress(&ip) == false)
+ {
+ Add(ip_list, Clone(&ip, sizeof(IP)));
+ }
+ }
+ }
+ }
+
+ Free(line);
+ }
+
+ FreeBuf(txt_buf);
+
+ ret = QueryFileByIPv6Udp(ip_list, timeout, cancel);
+
+ for (i = 0;i < LIST_NUM(ip_list);i++)
+ {
+ IP *ip = LIST_DATA(ip_list, i);
+
+ Free(ip);
+ }
+
+ ReleaseList(ip_list);
+
+ return ret;
+}
+
+// Request a file by UDP (send the requests to the multiple IP addresses at the same time)
+BUF *QueryFileByIPv6Udp(LIST *ip_list, UINT timeout, bool *cancel)
+{
+ bool dummy_flag = false;
+ UINT64 start_tick, giveup_tick;
+ UINT64 next_send_tick;
+ SOCK *s;
+ INTERRUPT_MANAGER *interrupt;
+ BUF *buf = NULL;
+ SOCK_EVENT *se;
+ UCHAR *tmp_buf;
+ UINT tmp_buf_size = 65535;
+ // Validate arguments
+ if (cancel == NULL)
+ {
+ cancel = &dummy_flag;
+ }
+ if (ip_list == NULL)
+ {
+ return NULL;
+ }
+
+ s = NewUDP6(0, NULL);
+ if (s == NULL)
+ {
+ return NULL;
+ }
+
+ tmp_buf = Malloc(tmp_buf_size);
+
+ start_tick = Tick64();
+ giveup_tick = start_tick + (UINT64)timeout;
+ next_send_tick = 0;
+
+ interrupt = NewInterruptManager();
+
+ AddInterrupt(interrupt, giveup_tick);
+
+ se = NewSockEvent();
+ JoinSockToSockEvent(s, se);
+
+ while (true)
+ {
+ UINT64 now = Tick64();
+
+ if (now >= giveup_tick)
+ {
+ // Time-out
+ break;
+ }
+
+ if (*cancel)
+ {
+ // User canceled
+ break;
+ }
+
+ // Receive
+ while (true)
+ {
+ IP src_ip;
+ UINT src_port;
+ UINT r;
+
+ r = RecvFrom(s, &src_ip, &src_port, tmp_buf, tmp_buf_size);
+
+ if (r == SOCK_LATER || r == 0)
+ {
+ break;
+ }
+
+ if (src_port == UDP_FILE_QUERY_DST_PORT)
+ {
+ if (r >= 40)
+ {
+ if (Cmp(tmp_buf, UDP_FILE_QUERY_MAGIC_NUMBER, StrLen(UDP_FILE_QUERY_MAGIC_NUMBER)) == 0)
+ {
+ // Successful reception
+ buf = NewBuf();
+ WriteBuf(buf, tmp_buf, r);
+ SeekBuf(buf, 0, 0);
+ break;
+ }
+ }
+ }
+ }
+
+ if (buf != NULL)
+ {
+ // Successful reception
+ break;
+ }
+
+ if (next_send_tick == 0 || (now >= next_send_tick))
+ {
+ // Transmission
+ UINT i;
+ for (i = 0;i < LIST_NUM(ip_list);i++)
+ {
+ IP *ip = LIST_DATA(ip_list, i);
+ UCHAR c = 'F';
+
+ SendTo(s, ip, UDP_FILE_QUERY_DST_PORT, &c, 1);
+ }
+
+ next_send_tick = now + (UINT64)UDP_FILE_QUERY_RETRY_INTERVAL;
+ AddInterrupt(interrupt, next_send_tick);
+ }
+
+ WaitSockEvent(se, GetNextIntervalForInterrupt(interrupt));
+ }
+
+ FreeInterruptManager(interrupt);
+
+ Disconnect(s);
+ ReleaseSock(s);
+
+ ReleaseSockEvent(se);
+
+ Free(tmp_buf);
+
+ return buf;
+}
+
+// Parse the user name of the NT
+void ParseNtUsername(char *src_username, char *dst_username, UINT dst_username_size, char *dst_domain, UINT dst_domain_size, bool do_not_parse_atmark)
+{
+ char tmp_username[MAX_SIZE];
+ char tmp_domain[MAX_SIZE];
+ TOKEN_LIST *t;
+
+ if (src_username != dst_username)
+ {
+ ClearStr(dst_username, dst_username_size);
+ }
+
+ ClearStr(dst_domain, dst_domain_size);
+ // Validate arguments
+ if (src_username == NULL || dst_username == NULL || dst_domain == NULL)
+ {
+ return;
+ }
+
+ StrCpy(tmp_username, sizeof(tmp_username), src_username);
+ ClearStr(tmp_domain, sizeof(tmp_domain));
+
+ // Analysis of username@domain.name format
+ if (do_not_parse_atmark == false)
+ {
+ t = ParseTokenWithNullStr(tmp_username, "@");
+ if (t->NumTokens >= 1)
+ {
+ StrCpy(tmp_username, sizeof(tmp_username), t->Token[0]);
+ }
+ if (t->NumTokens >= 2)
+ {
+ StrCpy(tmp_domain, sizeof(tmp_domain), t->Token[1]);
+ }
+ FreeToken(t);
+ }
+
+ // If the username part is in "domain\username" format, split it
+ t = ParseTokenWithNullStr(tmp_username, "\\");
+ if (t->NumTokens >= 2)
+ {
+ if (IsEmptyStr(tmp_domain))
+ {
+ StrCpy(tmp_domain, sizeof(tmp_domain), t->Token[0]);
+ }
+
+ StrCpy(tmp_username, sizeof(tmp_username), t->Token[1]);
+ }
+ FreeToken(t);
+
+ StrCpy(dst_username, dst_username_size, tmp_username);
+ StrCpy(dst_domain, dst_domain_size, tmp_domain);
+}
+
+// The calculation of the optimum MSS value for use in TCP/IP packet in the payload of bulk transfer in R-UDP session
+UINT RUDPCalcBestMssForBulk(RUDP_STACK *r, RUDP_SESSION *se)
+{
+ UINT ret;
+ // Validate arguments
+ if (r == NULL || se == NULL)
+ {
+ return 0;
+ }
+
+ ret = MTU_FOR_PPPOE;
+
+ // IPv4
+ if (IsIP6(&se->YourIp) == false)
+ {
+ ret -= 20;
+ }
+ else
+ {
+ ret -= 40;
+ }
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // ICMP
+ ret -= 8;
+
+ ret -= SHA1_SIZE;
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // UDP
+ ret -= 8;
+
+ // DNS
+ ret -= 42;
+ }
+
+ // IV
+ ret -= SHA1_SIZE;
+
+ // Sign
+ ret -= SHA1_SIZE;
+
+ // SEQ_NO
+ ret -= sizeof(UINT64);
+
+ // Padding Max
+ ret -= 31;
+
+ // Ethernet header (target packets of communication)
+ ret -= 14;
+
+ // IPv4 Header (target packet of communication)
+ ret -= 20;
+
+ // TCP header (target packet of communication)
+ ret -= 20;
+
+ // I don't know well, but subtract 24 bytes
+ ret -= 24;
+
+ return ret;
+}
+
+// Processing of the reply packet from the NAT-T server
+void RUDPProcess_NatT_Recv(RUDP_STACK *r, UDPPACKET *udp)
+{
+ BUF *b;
+ PACK *p;
+ // Validate arguments
+ if (r == NULL || udp == NULL)
+ {
+ return;
+ }
+
+ if (udp->Size >= 8)
+ {
+ char tmp[128];
+
+ Zero(tmp, sizeof(tmp));
+ Copy(tmp, udp->Data, MIN(udp->Size, sizeof(tmp) - 1));
+
+ if (StartWith(tmp, "IP="))
+ {
+ IP my_ip;
+ UINT my_port;
+
+ // There was a response to the packet to determine the NAT state
+ if (IsEmptyStr(r->NatT_Registered_IPAndPort) == false)
+ {
+ if (StrCmpi(r->NatT_Registered_IPAndPort, tmp) != 0)
+ {
+ // Redo getting the token and registration because the NAT state is changed
+ ClearStr(r->NatT_Registered_IPAndPort, sizeof(r->NatT_Registered_IPAndPort));
+
+ r->NatT_GetTokenNextTick = 0;
+ r->NatT_GetTokenFailNum = 0;
+ r->NatT_Token_Ok = false;
+ Zero(r->NatT_Token, sizeof(r->NatT_Token));
+
+ r->NatT_RegisterNextTick = 0;
+ r->NatT_RegisterFailNum = 0;
+ r->NatT_Register_Ok = false;
+ }
+ }
+
+ if (RUDPParseIPAndPortStr(udp->Data, udp->Size, &my_ip, &my_port))
+ {
+ if (r->NatTGlobalUdpPort != NULL)
+ {
+ *r->NatTGlobalUdpPort = my_port;
+ }
+ }
+
+ return;
+ }
+ }
+
+ // Interpret the UDP packet
+ b = NewBuf();
+ WriteBuf(b, udp->Data, udp->Size);
+ SeekBuf(b, 0, 0);
+
+ p = BufToPack(b);
+
+ if (p != NULL)
+ {
+ bool is_ok = PackGetBool(p, "ok");
+ UINT64 tran_id = PackGetInt64(p, "tran_id");
+
+ ExtractAndApplyDynList(p);
+
+ if (r->ServerMode)
+ {
+ if (PackCmpStr(p, "opcode", "get_token"))
+ {
+ // Get the Token
+ if (is_ok && (tran_id == r->NatT_TranId))
+ {
+ char tmp[MAX_SIZE];
+
+ if (PackGetStr(p, "token", tmp, sizeof(tmp)) && IsEmptyStr(tmp) == false)
+ {
+ char myip[MAX_SIZE];
+ // Acquisition success
+ StrCpy(r->NatT_Token, sizeof(r->NatT_Token), tmp);
+ r->NatT_Token_Ok = true;
+ r->NatT_GetTokenNextTick = r->Now + (UINT64)GenRandInterval(UDP_NAT_T_GET_TOKEN_INTERVAL_2_MIN, UDP_NAT_T_GET_TOKEN_INTERVAL_2_MAX);
+ r->NatT_GetTokenFailNum = 0;
+
+ // Since success to obtain the self global IPv4 address,
+ // re-obtain the destination NAT-T host from this IPv4 address
+ if (PackGetStr(p, "your_ip", myip, sizeof(myip)))
+ {
+ IP ip;
+ char new_hostname[MAX_SIZE];
+
+ StrToIP(&ip, myip);
+
+ SetCurrentGlobalIP(&ip, false);
+
+ RUDPGetRegisterHostNameByIP(new_hostname,
+ sizeof(new_hostname), &ip);
+
+ Lock(r->Lock);
+ {
+ if (StrCmpi(r->CurrentRegisterHostname, new_hostname) != 0)
+ {
+ // Change the host name
+ Debug("CurrentRegisterHostname Changed: New=%s\n", new_hostname);
+ StrCpy(r->CurrentRegisterHostname, sizeof(r->CurrentRegisterHostname), new_hostname);
+
+ Zero(&r->NatT_IP, sizeof(r->NatT_IP));
+ //Zero(&r->NatT_IP_Safe, sizeof(r->NatT_IP_Safe));
+
+ Set(r->HaltEvent);
+ }
+ }
+ Unlock(r->Lock);
+ }
+
+ AddInterrupt(r->Interrupt, r->NatT_GetTokenNextTick);
+ }
+ }
+ }
+ else if (PackCmpStr(p, "opcode", "nat_t_register"))
+ {
+ // NAT-T server registration result
+ if (is_ok && (tran_id == r->NatT_TranId))
+ {
+ UINT my_global_port;
+ // Successful registration
+ r->NatT_Register_Ok = true;
+ r->NatT_RegisterNextTick = r->Now + (UINT64)GenRandInterval(UDP_NAT_T_REGISTER_INTERVAL_MIN, UDP_NAT_T_REGISTER_INTERVAL_MAX);
+ r->NatT_RegisterFailNum = 0;
+
+ Debug("NAT-T Registered.\n");
+
+ // Save the IP address and port number at the time of registration
+ PackGetStr(p, "your_ip_and_port", r->NatT_Registered_IPAndPort, sizeof(r->NatT_Registered_IPAndPort));
+
+ // Global port of itself
+ my_global_port = PackGetInt(p, "your_port");
+
+ if (my_global_port != 0)
+ {
+ if (r->NatTGlobalUdpPort != NULL)
+ {
+ *r->NatTGlobalUdpPort = my_global_port;
+ }
+ }
+
+ AddInterrupt(r->Interrupt, r->NatT_RegisterNextTick);
+ }
+ }
+ else if (PackCmpStr(p, "opcode", "nat_t_connect_relay"))
+ {
+ // Connection request from the client via the NAT-T server
+ if (is_ok)
+ {
+ char client_ip_str[MAX_SIZE];
+ UINT client_port;
+ IP client_ip;
+
+ PackGetStr(p, "client_ip", client_ip_str, sizeof(client_ip_str));
+ client_port = PackGetInt(p, "client_port");
+ StrToIP(&client_ip, client_ip_str);
+
+ if (IsZeroIp(&client_ip) == false && client_port != 0)
+ {
+ UCHAR *rand_data;
+ UINT rand_size;
+
+ rand_size = Rand32() % 19;
+ rand_data = Malloc(rand_size);
+
+ Rand(rand_data, rand_size);
+
+ RUDPSendPacket(r, &client_ip, client_port, rand_data, rand_size, 0);
+
+ Free(rand_data);
+ }
+ }
+ }
+ }
+
+ FreePack(p);
+ }
+
+ FreeBuf(b);
+}
+
+// Process such as packet transmission for NAT-T server
+void RUDPDo_NatT_Interrupt(RUDP_STACK *r)
+{
+ // Validate arguments
+ if (r == NULL)
+ {
+ return;
+ }
+
+ if (r->ServerMode)
+ {
+ if (IsZeroIp(&r->NatT_IP_Safe) == false)
+ {
+ if (g_no_rudp_register == false)
+ {
+ if (r->NatT_GetTokenNextTick == 0 || r->Now >= r->NatT_GetTokenNextTick)
+ {
+ // Try to get a token from the NAT-T server periodically
+ PACK *p = NewPack();
+ BUF *b;
+
+ PackAddStr(p, "opcode", "get_token");
+ PackAddInt64(p, "tran_id", r->NatT_TranId);
+ PackAddInt(p, "nat_traversal_version", UDP_NAT_TRAVERSAL_VERSION);
+
+ b = PackToBuf(p);
+ FreePack(p);
+
+ RUDPSendPacket(r, &r->NatT_IP_Safe, UDP_NAT_T_PORT, b->Buf, b->Size, 0);
+
+ FreeBuf(b);
+
+ // Determine the next acquisition time
+ r->NatT_GetTokenFailNum++;
+ r->NatT_GetTokenNextTick = r->Now + (UINT64)(UDP_NAT_T_GET_TOKEN_INTERVAL_1 * (UINT64)MIN(r->NatT_GetTokenFailNum, UDP_NAT_T_GET_TOKEN_INTERVAL_FAIL_MAX));
+ AddInterrupt(r->Interrupt, r->NatT_GetTokenNextTick);
+ r->NatT_Token_Ok = false;
+ }
+ }
+
+ if (r->NatT_NextNatStatusCheckTick == 0 || r->Now >= r->NatT_NextNatStatusCheckTick)
+ {
+ UCHAR a = 'A';
+ UINT ddns_hash;
+ // Check of the NAT state
+ RUDPSendPacket(r, &r->NatT_IP_Safe, UDP_NAT_T_PORT, &a, 1, 0);
+
+ // Execution time of the next
+ r->NatT_NextNatStatusCheckTick = r->Now + (UINT64)GenRandInterval(UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MIN, UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MAX);
+ AddInterrupt(r->Interrupt, r->NatT_NextNatStatusCheckTick);
+
+ // Check whether the DDNS host name changing have not occurred
+ ddns_hash = GetCurrentDDnsFqdnHash();
+
+ if (r->LastDDnsFqdnHash != ddns_hash)
+ {
+ r->LastDDnsFqdnHash = ddns_hash;
+ // Do the Register immediately if there is a change in the DDNS host name
+ r->NatT_RegisterNextTick = 0;
+ }
+ }
+
+ if (r->NatT_Token_Ok && g_no_rudp_register == false)
+ {
+ if (r->NatT_RegisterNextTick == 0 || r->Now >= r->NatT_RegisterNextTick)
+ {
+ // Try to register itself periodically for NAT-T server
+ PACK *p = NewPack();
+ BUF *b;
+ char private_ip_str[MAX_SIZE];
+ char machine_key[MAX_SIZE];
+ char machine_name[MAX_SIZE];
+ UCHAR hash[SHA1_SIZE];
+ char ddns_fqdn[MAX_SIZE];
+
+ Debug("NAT-T Registering...\n");
+
+ GetCurrentDDnsFqdn(ddns_fqdn, sizeof(ddns_fqdn));
+
+ PackAddStr(p, "opcode", "nat_t_register");
+ PackAddInt64(p, "tran_id", r->NatT_TranId);
+ PackAddStr(p, "token", r->NatT_Token);
+ PackAddStr(p, "svc_name", r->SvcName);
+ PackAddStr(p, "product_str", CEDAR_PRODUCT_STR);
+ PackAddInt(p, "nat_traversal_version", UDP_NAT_TRAVERSAL_VERSION);
+
+
+ if (g_natt_low_priority)
+ {
+ PackAddBool(p, "low_priority", g_natt_low_priority);
+ }
+
+ Zero(private_ip_str, sizeof(private_ip_str));
+ if (IsZeroIp(&r->My_Private_IP_Safe) == false)
+ {
+ IPToStr(private_ip_str, sizeof(private_ip_str), &r->My_Private_IP_Safe);
+ PackAddStr(p, "private_ip", private_ip_str);
+ }
+
+ PackAddInt(p, "private_port", r->UdpSock->LocalPort);
+
+ Zero(hash, sizeof(hash));
+ GetCurrentMachineIpProcessHash(hash);
+ BinToStr(machine_key, sizeof(machine_key), hash, sizeof(hash));
+ PackAddStr(p, "machine_key", machine_key);
+
+ Zero(machine_name, sizeof(machine_name));
+ GetMachineName(machine_name, sizeof(machine_name));
+ PackAddStr(p, "host_name", machine_name);
+ PackAddStr(p, "ddns_fqdn", ddns_fqdn);
+
+ b = PackToBuf(p);
+ FreePack(p);
+
+ RUDPSendPacket(r, &r->NatT_IP_Safe, UDP_NAT_T_PORT, b->Buf, b->Size, 0);
+ //RUDPSendPacket(r, &r->NatT_IP_Safe, UDP_NAT_T_PORT, "a", 1);
+
+ FreeBuf(b);
+
+ // Determine the next acquisition time
+ r->NatT_RegisterFailNum++;
+ r->NatT_RegisterNextTick = r->Now + (UINT64)UDP_NAT_T_REGISTER_INTERVAL_INITIAL * (UINT64)MIN(r->NatT_RegisterFailNum, UDP_NAT_T_REGISTER_INTERVAL_FAIL_MAX);
+ AddInterrupt(r->Interrupt, r->NatT_RegisterNextTick);
+ r->NatT_Register_Ok = false;
+ }
+ }
+ }
+ }
+}
+
+// R-UDP packet reception procedure
+void RUDPRecvProc(RUDP_STACK *r, UDPPACKET *p)
+{
+ RUDP_SESSION *se = NULL;
+ // Validate arguments
+ if (r == NULL || p == NULL)
+ {
+ return;
+ }
+
+ if (r->ServerMode && r->NoNatTRegister == false)
+ {
+ if (p->SrcPort == UDP_NAT_T_PORT && CmpIpAddr(&p->SrcIP, &r->NatT_IP_Safe) == 0)
+ {
+ // There was a response from the NAT-T server
+ RUDPProcess_NatT_Recv(r, p);
+ return;
+ }
+ }
+
+ if (r->ServerMode)
+ {
+ if (r->ProcRpcRecv != NULL)
+ {
+ if (r->ProcRpcRecv(r, p))
+ {
+ return;
+ }
+ }
+ }
+
+ if (r->ServerMode)
+ {
+ // Search the session by the end-point information if in the server mode
+ se = RUDPSearchSession(r, &p->DstIP, p->DestPort, &p->SrcIP, p->SrcPort);
+ }
+ else
+ {
+ // Session should exist only one in the case of client mode
+ if (LIST_NUM(r->SessionList) >= 1)
+ {
+ se = LIST_DATA(r->SessionList, 0);
+ }
+ else
+ {
+ se = NULL;
+ }
+ }
+
+ if (p->Size < 20)
+ {
+ // The received packet is too small
+ if (r->ServerMode == false)
+ {
+ if (se != NULL && se->Status == RUDP_SESSION_STATUS_CONNECT_SENT)
+ {
+ if (CmpIpAddr(&se->YourIp, &p->SrcIP) == 0)
+ {
+ // If the connection initialization packet which is shorter than 20 bytes
+ // has been received from the server side, overwrite the source port number
+ // of the packet to the client-side session information (for some NAT)
+ se->YourPort = p->SrcPort;
+ }
+ }
+ }
+ return;
+ }
+
+ if (se == NULL && r->ServerMode && p->Size >= 40)
+ {
+ // Corresponding to a sudden change of port number on the client side.
+ // 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++)
+ {
+ RUDP_SESSION *s = LIST_DATA(r->SessionList, i);
+
+ if (CmpIpAddr(&s->YourIp, &p->SrcIP) == 0)
+ {
+ if (RUDPCheckSignOfRecvPacket(r, s, p->Data, p->Size))
+ {
+ // Signature matched
+ se = s;
+ break;
+ }
+ }
+ }
+ }
+
+ if (se == NULL)
+ {
+ // There is no session
+ if (r->ServerMode)
+ {
+ if (p->Size < 40)
+ {
+ bool ok = true;
+ UCHAR ctoken_hash[SHA1_SIZE];
+
+ Zero(ctoken_hash, sizeof(ctoken_hash));
+
+ // Examine the quota of new session creation
+ if (LIST_NUM(r->SessionList) >= RUDP_QUOTA_MAX_NUM_SESSIONS)
+ {
+ // Entire number of sessions exceeds the limit
+ ok = false;
+ }
+ else
+ {
+ UINT i;
+ // Check the number of sessions per IP address
+ UINT num = 0;
+
+ for (i = 0;i < LIST_NUM(r->SessionList);i++)
+ {
+ RUDP_SESSION *se = LIST_DATA(r->SessionList, i);
+
+ if (CmpIpAddr(&se->YourIp, &p->SrcIP) == 0)
+ {
+ num++;
+ }
+ }
+
+ if (num >= RUDP_QUOTA_MAX_NUM_SESSIONS_PER_IP)
+ {
+ // Limit exceeded the number of sessions per IP address
+ ok = false;
+ }
+ }
+
+
+ if (ok)
+ {
+ char ip_str[64];
+
+ // Create a session since a new session creation request packet was received
+ se = RUDPNewSession(true, &p->DstIP, p->DestPort, &p->SrcIP, p->SrcPort, p->Data);
+ se->Status = RUDP_SESSION_STATUS_ESTABLISHED;
+ Insert(r->SessionList, se);
+
+ IPToStr(ip_str, sizeof(ip_str), &p->SrcIP);
+ Debug("RUDPNewSession %X %s:%u\n", se, ip_str, p->SrcPort);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // In case of ICMP, save the ICMP TYPE number to use
+ se->Icmp_Type = (p->Type == ICMP_TYPE_INFORMATION_REQUEST ? ICMP_TYPE_INFORMATION_REPLY : p->Type);
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // Save the Tran ID to be used if it's a DNS
+ se->Dns_TranId = (USHORT)p->Type;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ if (p->Size < 40)
+ {
+ if (r->ServerMode)
+ {
+ if (Cmp(se->Key_Init, p->Data, SHA1_SIZE) == 0)
+ {
+ // New session creation request packet have received more than once. reply an ACK immediately for second and subsequent
+ se->LastSentTick = 0;
+
+ // Update the endpoint information
+ Copy(&se->YourIp, &p->SrcIP, sizeof(IP));
+ se->YourPort = p->SrcPort;
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // In case of ICMP, save the ICMP TYPE number to use
+ se->Icmp_Type = (p->Type == ICMP_TYPE_INFORMATION_REQUEST ? ICMP_TYPE_INFORMATION_REPLY : p->Type);
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // Save the Tran ID to be used if it's a DNS
+ se->Dns_TranId = (USHORT)p->Type;
+ }
+ }
+ else
+ {
+ // Since the different session creation request packet have been received from the same end point, ignore it
+ }
+ }
+ }
+ else
+ {
+ // Process the received packet
+ if (RUDPProcessRecvPacket(r, se, p->Data, p->Size) || RUDPProcessBulkRecvPacket(r, se, p->Data, p->Size))
+ {
+ // Update endpoint information (only the port number)
+ //Copy(&se->YourIp, &p->SrcIP, sizeof(IP));
+ se->YourPort = p->SrcPort;
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // In case of ICMP, save the ICMP TYPE number to use
+ if (r->ServerMode)
+ {
+ se->Icmp_Type = (p->Type == ICMP_TYPE_INFORMATION_REQUEST ? ICMP_TYPE_INFORMATION_REPLY : p->Type);
+ }
+ else
+ {
+ se->Icmp_Type = (p->Type == ICMP_TYPE_INFORMATION_REPLY ? ICMP_TYPE_INFORMATION_REQUEST : p->Type);
+ }
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ if (r->ServerMode)
+ {
+ // Save the Tran ID to be used if it's a DNS
+ se->Dns_TranId = (USHORT)p->Type;
+ }
+ }
+ }
+ }
+ }
+}
+
+// R-UDP interrupt processing procedure
+void RUDPInterruptProc(RUDP_STACK *r)
+{
+ UINT i;
+ LIST *o;
+ // Validate arguments
+ if (r == NULL)
+ {
+ return;
+ }
+
+ // Packet transmission and other process for NAT-T server
+ if (r->NoNatTRegister == false)
+ {
+ RUDPDo_NatT_Interrupt(r);
+ }
+
+ if (r->ServerMode == false)
+ {
+ if (r->ClientInitiated == false)
+ {
+ bool client_target_inited = false;
+ Lock(r->Lock);
+ {
+ client_target_inited = r->TargetIpAndPortInited;
+ }
+ Unlock(r->Lock);
+
+ if (client_target_inited)
+ {
+ // Start a connection when there is the end point information of the destination server to connect as a client
+ RUDP_SESSION *se;
+ UCHAR init_key[SHA1_SIZE];
+ char ip_str[128];
+ UINT64 ui;
+
+ Rand(init_key, SHA1_SIZE);
+
+ se = RUDPNewSession(false, &r->UdpSock->LocalIP, r->UdpSock->LocalPort,
+ &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);
+
+ Insert(r->SessionList, se);
+
+ ui = Endian64(se->Magic_Disconnect);
+ WriteFifo(se->SendFifo, &ui, sizeof(UINT64));
+
+ r->ClientInitiated = true;
+ }
+ }
+ }
+
+ // Process for all the sessions
+ for (i = 0;i < LIST_NUM(r->SessionList);i++)
+ {
+ RUDP_SESSION *se = LIST_DATA(r->SessionList, i);
+
+ if (r->Halt)
+ {
+ // Disconnect all the sessions if the R-UDP stack stopped
+ RUDPDisconnectSession(r, se, false);
+ }
+
+ if (se->FlushBulkSendTube)
+ {
+ if (se->TcpSock != NULL && se->TcpSock->BulkSendTube != NULL)
+ {
+ TubeFlush(se->TcpSock->BulkSendTube);
+ }
+
+ se->FlushBulkSendTube = false;
+ }
+
+ if (se->Status == RUDP_SESSION_STATUS_ESTABLISHED)
+ {
+ // Process for all of the sessions which is established a connection
+ UINT j;
+
+ if (r->Now >= (se->LatestRecvMyTick + (UINT64)RUDP_TIMEOUT))
+ {
+ // Disconnect the session because the fully communication failure is detected for a while
+ Debug("R-UDP Session %X Timed Out.\n", se);
+
+ RUDPDisconnectSession(r, se, false);
+ }
+
+ // If there are received segments, read to the part that has arrived in succession
+ if (FifoSize(se->RecvFifo) <= RUDP_MAX_FIFO_SIZE)
+ {
+ LIST *o;
+ UINT64 current_seq_no;
+
+ o = NULL;
+ current_seq_no = se->LastRecvCompleteSeqNo;
+ for (j = 0;j < LIST_NUM(se->RecvSegmentList);j++)
+ {
+ RUDP_SEGMENT *s;
+
+ current_seq_no++;
+
+ s = LIST_DATA(se->RecvSegmentList, j);
+
+ if (s->SeqNo == current_seq_no)
+ {
+#ifdef RUDP_DETAIL_LOG
+ Debug("%X s->SeqNo = %I64u, current_seq_no = %I64u\n", se, s->SeqNo, current_seq_no);
+#endif // RUDP_DETAIL_LOG
+
+ if (s->Size == sizeof(se->Magic_KeepAliveRequest) && Cmp(s->Data, se->Magic_KeepAliveRequest, sizeof(se->Magic_KeepAliveRequest)) == 0)
+ {
+ // Receive the KeepAlive Request
+#ifdef RUDP_DETAIL_LOG
+ Debug("Recv KeepAlive Request\n");
+#endif // RUDP_DETAIL_LOG
+
+ // Send a KeepAlive Response if the transmisson queue is empty
+ if (LIST_NUM(se->SendSegmentList) == 0)
+ {
+#ifdef RUDP_DETAIL_LOG
+ Debug("Send KeepAlive Response\n");
+#endif // RUDP_DETAIL_LOG
+
+ RUDPSendSegment(r, se, se->Magic_KeepAliveResponse, sizeof(se->Magic_KeepAliveResponse));
+ }
+ }
+ else if (s->Size == sizeof(se->Magic_KeepAliveResponse) && Cmp(s->Data, se->Magic_KeepAliveResponse, sizeof(se->Magic_KeepAliveResponse)) == 0)
+ {
+ // Receive the KeepAlive Response
+#ifdef RUDP_DETAIL_LOG
+ Debug("Recv KeepAlive Response\n");
+#endif // RUDP_DETAIL_LOG
+ }
+ else
+ {
+ // Write to the receive FIFO
+ WriteFifo(se->RecvFifo, s->Data, s->Size);
+ }
+ r->TotalLogicalReceived += s->Size;
+
+ // Advance the SEQ NO which has been received completely
+ se->LastRecvCompleteSeqNo = s->SeqNo;
+
+ // Add to the Delete list
+ if (o == NULL)
+ {
+ o = NewListFast(NULL);
+ }
+ Add(o, s);
+ }
+ else
+ {
+ // Continuous reading is interrupted
+#ifdef RUDP_DETAIL_LOG
+ Debug("%X s->SeqNo = %I64u, current_seq_no = %I64u\n", se, s->SeqNo, current_seq_no);
+ WHERE;
+#endif // RUDP_DETAIL_LOG
+ break;
+ }
+ }
+
+ // Delete the segment which has been received completely
+ if (o != NULL)
+ {
+ for (j = 0;j < LIST_NUM(o);j++)
+ {
+ RUDP_SEGMENT *s = LIST_DATA(o, j);
+
+ Delete(se->RecvSegmentList, s);
+ Free(s);
+ }
+ ReleaseList(o);
+ }
+ }
+
+ if (r->ServerMode && se->Magic_Disconnect == 0)
+ {
+ if (FifoSize(se->RecvFifo) >= sizeof(UINT64))
+ {
+ UINT64 ui;
+
+ if (ReadFifo(se->RecvFifo, &ui, sizeof(UINT64)) == sizeof(UINT64))
+ {
+ ui = Endian64(ui);
+
+ if ((ui & 0xffffffff00000000ULL) != 0ULL)
+ {
+ se->Magic_Disconnect = ui;
+ }
+ }
+ }
+ }
+
+ // If the data remains in FIFO, write it to the TCP socket as possible
+ if (r->ServerMode == false || se->Magic_Disconnect != 0)
+ {
+ while (FifoSize(se->RecvFifo) >= 1)
+ {
+ UINT ret;
+
+ RUDPInitSock(r, se);
+
+ ret = Send(se->TcpSock, FifoPtr(se->RecvFifo), FifoSize(se->RecvFifo), false);
+
+ if (ret == SOCK_LATER)
+ {
+ // Can not write any more
+ break;
+ }
+ else if (ret == 0)
+ {
+ // Disconnected
+ Disconnect(se->TcpSock);
+ RUDPDisconnectSession(r, se, false);
+ break;
+ }
+ else
+ {
+ // Writing success
+ ReadFifo(se->RecvFifo, NULL, ret);
+ }
+ }
+ }
+
+ // Read the data as much as possible from the TCP socket and store it to FIFO
+ if (se->TcpSock != NULL)
+ {
+ SetNoNeedToRead(se->TcpSock);
+
+ while (FifoSize(se->SendFifo) <= RUDP_MAX_FIFO_SIZE)
+ {
+ UINT ret = Recv(se->TcpSock, r->TmpBuf, sizeof(r->TmpBuf), false);
+
+ if (ret == SOCK_LATER)
+ {
+ // Can not read any more
+ break;
+ }
+ else if (ret == 0)
+ {
+ // Disconnected
+ Disconnect(se->TcpSock);
+ RUDPDisconnectSession(r, se, false);
+ break;
+ }
+ else
+ {
+ // Reading success
+ WriteFifo(se->SendFifo, r->TmpBuf, ret);
+ }
+ }
+ }
+
+ // Attempt to send a divided segment
+ while (true)
+ {
+ UINT64 seq_no_min, seq_no_max;
+
+ seq_no_min = RUDPGetCurrentSendingMinSeqNo(se);
+ seq_no_max = RUDPGetCurrentSendingMaxSeqNo(se);
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("min=%I64u max=%I64u\n", seq_no_min, seq_no_max);
+#endif // RUDP_DETAIL_LOG
+
+ if (seq_no_min == 0 || ((seq_no_min + RUDP_MAX_NUM_ACK - 1) >= se->NextSendSeqNo))
+ {
+ // Because there is a room to send a new segment, send a segment
+ UINT size = MIN(FifoSize(se->SendFifo), RUDP_MAX_SEGMENT_SIZE);
+
+ if (size == 0)
+ {
+ // There is no more data to send in FIFO
+ break;
+ }
+
+ // Transmission
+ RUDPSendSegment(r, se, FifoPtr(se->SendFifo), size);
+
+ r->TotalLogicalSent += size;
+
+ // Advance the FIFO
+ ReadFifo(se->SendFifo, NULL, size);
+ }
+ else
+ {
+ // There is no room to send a new segment further
+ break;
+ }
+ }
+
+ if (se->DisconnectFlag == false)
+ {
+ UINT64 seq_no_min;
+
+ if (se->LastSentTick == 0 || (r->Now >= (se->LastSentTick + (UINT64)se->NextKeepAliveInterval)))
+ {
+ if (LIST_NUM(se->SendSegmentList) == 0)
+ {
+ // Send a Keep-Alive if no data was sent for a while and the transmission queue is empty
+ RUDPSendSegment(r, se, se->Magic_KeepAliveRequest, sizeof(se->Magic_KeepAliveRequest));
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("Sent KeepAlive Request\n");
+#endif // RUDP_DETAIL_LOG
+ }
+
+ se->NextKeepAliveInterval = RUDP_KEEPALIVE_INTERVAL_MIN + (Rand32() % (RUDP_KEEPALIVE_INTERVAL_MAX - RUDP_KEEPALIVE_INTERVAL_MIN));
+
+ AddInterrupt(r->Interrupt, r->Now + se->NextKeepAliveInterval);
+ }
+
+ seq_no_min = RUDPGetCurrentSendingMinSeqNo(se);
+ for (j = 0;j < LIST_NUM(se->SendSegmentList);j++)
+ {
+ RUDP_SEGMENT *s = LIST_DATA(se->SendSegmentList, j);
+
+ if (s->SeqNo <= (seq_no_min + RUDP_MAX_NUM_ACK - 1))
+ {
+ if (s->NextSendTick == 0 || r->Now >= s->NextSendTick)
+ {
+ UINT next_interval;
+ // Transmits a segment which has not been sent even once yet, or whose retransmission time has arrived
+ RUDPSendSegmentNow(r, se, s->SeqNo, s->Data, s->Size);
+
+ if (se->CurrentRtt != 0)
+ {
+ next_interval = (se->CurrentRtt * 120 / 100) * Power(2, MIN(s->NumSent, 10));
+ }
+ else
+ {
+ next_interval = RUDP_RESEND_TIMER * Power(2, MIN(s->NumSent, 10));
+ }
+
+ next_interval = MIN(next_interval, RUDP_RESEND_TIMER_MAX);
+
+ s->NumSent++;
+
+ s->NextSendTick = r->Now + next_interval;
+
+ AddInterrupt(r->Interrupt, s->NextSendTick);
+ }
+ }
+ }
+
+ while (LIST_NUM(se->ReplyAckList) >= 1)
+ {
+ // If there are ACKs which is not responded yet in the list, send all of them
+ RUDPSendSegmentNow(r, se, se->NextSendSeqNo, NULL, 0);
+ }
+
+ // Send all if there are bulk transfer data
+ if (se->TcpSock != NULL)
+ {
+ SOCK *s = se->TcpSock;
+
+ if (s->BulkRecvTube != NULL)
+ {
+ TUBE *t = s->BulkRecvTube;
+
+ while (true)
+ {
+ TUBEDATA *d = TubeRecvAsync(t);
+
+ if (d == NULL)
+ {
+ break;
+ }
+
+ if (d->Header != NULL && d->HeaderSize == sizeof(TCP_PAIR_HEADER))
+ {
+ TCP_PAIR_HEADER *h = d->Header;
+
+ if (h->EnableHMac)
+ {
+ se->UseHMac = true;
+ }
+ }
+
+ RUDPBulkSend(r, se, d->Data, d->DataSize);
+
+ FreeTubeData(d);
+ }
+ }
+ }
+ }
+ }
+
+ if (r->ServerMode == false)
+ {
+ if (se->Status == RUDP_SESSION_STATUS_CONNECT_SENT)
+ {
+ // Send a connection request periodically from the client side
+ if (se->LastSentTick == 0 || ((se->LastSentTick + (UINT64)RUDP_RESEND_TIMER) <= r->Now))
+ {
+ UCHAR tmp[40];
+ UINT size_of_padding = 19;
+ UINT size = size_of_padding + SHA1_SIZE;
+
+ se->LastSentTick = r->Now;
+
+ Copy(tmp, se->Key_Init, SHA1_SIZE);
+ Rand(tmp + SHA1_SIZE, size_of_padding);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // ICMP packet
+ UCHAR *rand_data;
+ UINT rand_size;
+
+ rand_size = Rand32() % 64 + 64;
+ rand_data = Malloc(rand_size);
+ Rand(rand_data, rand_size);
+
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, rand_data, rand_size, ICMP_TYPE_ECHO_REQUEST);
+ Free(rand_data);
+
+ se->Client_Icmp_NextSendEchoRequest = r->Now + GenRandInterval(RUDP_CLIENT_ECHO_REQUEST_SEND_INTERVAL_MIN, RUDP_CLIENT_ECHO_REQUEST_SEND_INTERVAL_MAX);
+ AddInterrupt(r->Interrupt, se->Client_Icmp_NextSendEchoRequest);
+
+ // Try in both INFORMATION_REQUEST and ECHO_RESPONSE from the client side first
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, tmp, size, ICMP_TYPE_ECHO_RESPONSE);
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, tmp, size, ICMP_TYPE_INFORMATION_REQUEST);
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // DNS
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, tmp, size, se->Dns_TranId);
+ }
+ else
+ {
+ // Normal UDP
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, tmp, size, 0);
+ }
+
+ AddInterrupt(r->Interrupt, r->Now + (UINT64)RUDP_RESEND_TIMER);
+ }
+ }
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ if (se->Client_Icmp_NextSendEchoRequest == 0 || (r->Now >= se->Client_Icmp_NextSendEchoRequest))
+ {
+ // Periodic ICMP Echo transmission from the client side when R-UDP used in ICMP mode
+ // (To maintain the mapping table of the NAT)
+ UCHAR *rand_data;
+ UINT rand_size;
+
+ rand_size = Rand32() % 64 + 64;
+ rand_data = Malloc(rand_size);
+ Rand(rand_data, rand_size);
+
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, rand_data, rand_size, ICMP_TYPE_ECHO_REQUEST);
+ Free(rand_data);
+
+ se->Client_Icmp_NextSendEchoRequest = r->Now + GenRandInterval(RUDP_CLIENT_ECHO_REQUEST_SEND_INTERVAL_MIN, RUDP_CLIENT_ECHO_REQUEST_SEND_INTERVAL_MAX);
+ AddInterrupt(r->Interrupt, se->Client_Icmp_NextSendEchoRequest);
+ }
+ }
+ }
+ }
+
+ // Release the disconnected sessions
+ o = NULL;
+ for (i = 0;i < LIST_NUM(r->SessionList);i++)
+ {
+ RUDP_SESSION *se = LIST_DATA(r->SessionList, i);
+
+ if (se->DisconnectFlag)
+ {
+ if (o == NULL)
+ {
+ o = NewListFast(NULL);
+ }
+
+ Add(o, se);
+ }
+ }
+ if (o != NULL)
+ {
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ RUDP_SESSION *se = LIST_DATA(o, i);
+
+ Delete(r->SessionList, se);
+
+ RUDPFreeSession(se);
+ }
+
+ ReleaseList(o);
+ }
+}
+
+// Do the bulk send
+void RUDPBulkSend(RUDP_STACK *r, RUDP_SESSION *se, void *data, UINT data_size)
+{
+ UCHAR *buf;
+ UINT buf_size;
+ UINT padding_size;
+ UINT i;
+ CRYPT *c;
+ UCHAR crypt_key_src[SHA1_SIZE * 2];
+ UCHAR crypt_key[SHA1_SIZE];
+ UINT icmp_type;
+ UCHAR sign[SHA1_SIZE];
+ UCHAR iv[SHA1_SIZE + 1];
+ // Validate arguments
+ if (r == NULL || se == NULL || (data == NULL && data_size != 0))
+ {
+ return;
+ }
+
+ padding_size = Rand32() % 31 + 1;
+
+ buf_size = SHA1_SIZE + SHA1_SIZE + sizeof(UINT64) + data_size + padding_size;
+ buf = Malloc(buf_size);
+
+ // SEQ NO
+ WRITE_UINT64(buf + SHA1_SIZE + SHA1_SIZE, se->BulkNextSeqNo);
+ se->BulkNextSeqNo++;
+
+ // Data
+ Copy(buf + SHA1_SIZE + SHA1_SIZE + sizeof(UINT64), data, data_size);
+
+ // Padding
+ for (i = 0;i < padding_size;i++)
+ {
+ buf[SHA1_SIZE + SHA1_SIZE + sizeof(UINT64) + data_size + i] = (UCHAR)padding_size;
+ }
+
+ // Encryption
+ Copy(iv, se->BulkNextIv, SHA1_SIZE);
+ Copy(crypt_key_src + 0, se->BulkSendKey->Data, SHA1_SIZE);
+ Copy(crypt_key_src + SHA1_SIZE, iv, SHA1_SIZE);
+ HashSha1(crypt_key, crypt_key_src, SHA1_SIZE * 2);
+ c = NewCrypt(crypt_key, sizeof(crypt_key));
+ Encrypt(c, buf + SHA1_SIZE + SHA1_SIZE, buf + SHA1_SIZE + SHA1_SIZE, sizeof(UINT64) + data_size + padding_size);
+ FreeCrypt(c);
+
+ // IV
+ Copy(buf + SHA1_SIZE, iv, SHA1_SIZE);
+
+ // Sign
+ if (se->UseHMac == false)
+ {
+ Copy(buf + 0, se->BulkSendKey->Data, SHA1_SIZE);
+ HashSha1(sign, buf, SHA1_SIZE + SHA1_SIZE + sizeof(UINT64) + data_size + padding_size);
+ Copy(buf + 0, sign, SHA1_SIZE);
+ }
+ else
+ {
+ HMacSha1(buf + 0, se->BulkSendKey->Data, SHA1_SIZE, buf + SHA1_SIZE, SHA1_SIZE + sizeof(UINT64) + data_size + padding_size);
+ }
+
+ // Next IV
+ Copy(se->BulkNextIv, buf + buf_size - SHA1_SIZE, SHA1_SIZE);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ icmp_type = se->Icmp_Type;
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ icmp_type = se->Dns_TranId;
+ }
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, buf, buf_size, icmp_type);
+
+ Free(buf);
+}
+
+// Start a socket for R-UDP Listening
+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)
+{
+ return ListenRUDPEx(svc_name, proc_interrupts, proc_rpc_recv, param, port, no_natt_register, over_dns_mode, NULL, 0);
+}
+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)
+{
+ SOCK *s;
+ RUDP_STACK *r;
+
+ // Creating a R-UDP stack
+ r = NewRUDPServer(svc_name, proc_interrupts, proc_rpc_recv, param, port, no_natt_register, over_dns_mode, natt_global_udp_port, rand_port_id);
+ if (r == NULL)
+ {
+ return NULL;
+ }
+
+ s = NewSock();
+
+ s->Type = SOCK_RUDP_LISTEN;
+ s->ListenMode = true;
+ s->Connected = true;
+
+ s->LocalPort = r->UdpSock->LocalPort;
+
+ s->R_UDP_Stack = r;
+
+ return s;
+}
+
+// Accept on the R-UDP socket
+SOCK *AcceptRUDP(SOCK *s)
+{
+ // Validate arguments
+ if (s == NULL || s->Type != SOCK_RUDP_LISTEN || s->ListenMode == false)
+ {
+ return NULL;
+ }
+
+ while (true)
+ {
+ RUDP_STACK *r = s->R_UDP_Stack;
+ SOCK *ret;
+
+ if (s->Disconnecting || s->CancelAccept)
+ {
+ return NULL;
+ }
+
+ ret = GetNextWithLock(r->NewSockQueue);
+
+ if (ret != NULL)
+ {
+ switch (r->Protocol)
+ {
+ case RUDP_PROTOCOL_UDP:
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_NAT_T);
+ break;
+
+ case RUDP_PROTOCOL_DNS:
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_DNS);
+ break;
+
+ case RUDP_PROTOCOL_ICMP:
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_ICMP);
+ break;
+ }
+
+ return ret;
+ }
+
+ Wait(r->NewSockConnectEvent, INFINITE);
+ }
+}
+
+// Verify the signature of the received packet
+bool RUDPCheckSignOfRecvPacket(RUDP_STACK *r, RUDP_SESSION *se, void *recv_data, UINT recv_size)
+{
+ UCHAR sign[SHA1_SIZE];
+ UCHAR sign2[SHA1_SIZE];
+ UCHAR *p;
+ UINT size;
+ // Validate arguments
+ if (r == NULL || se == NULL || recv_data == NULL || recv_size == 0)
+ {
+ return false;
+ }
+
+ p = (UCHAR *)recv_data;
+ size = recv_size;
+ if (size < SHA1_SIZE)
+ {
+ return false;
+ }
+
+ // Verification the signature (segment packet)
+ Copy(sign, p, SHA1_SIZE);
+ Copy(p, se->Key_Recv, SHA1_SIZE);
+ HashSha1(sign2, p, recv_size);
+
+ if (r->Protocol == RUDP_PROTOCOL_DNS || r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ XorData(sign2, sign2, r->SvcNameHash, SHA1_SIZE);
+ }
+
+ Copy(p, sign, SHA1_SIZE);
+ if (Cmp(sign, sign2, SHA1_SIZE) == 0)
+ {
+ return true;
+ }
+
+ if (se->BulkRecvKey == NULL)
+ {
+ return false;
+ }
+
+ // Verification signature (bulk packet)
+ if (se->UseHMac == false)
+ {
+ Copy(sign, p, SHA1_SIZE);
+ Copy(p, se->BulkRecvKey->Data, SHA1_SIZE);
+ HashSha1(sign2, p, recv_size);
+ Copy(p, sign, SHA1_SIZE);
+
+ if (Cmp(sign, sign2, SHA1_SIZE) == 0)
+ {
+ return true;
+ }
+ }
+
+ HMacSha1(sign2, se->BulkRecvKey->Data, SHA1_SIZE, p + SHA1_SIZE, size - SHA1_SIZE);
+ if (Cmp(p, sign2, SHA1_SIZE) == 0)
+ {
+ se->UseHMac = true;
+ return true;
+ }
+
+ return false;
+}
+
+// Process the received packet (bulk)
+bool RUDPProcessBulkRecvPacket(RUDP_STACK *r, RUDP_SESSION *se, void *recv_data, UINT recv_size)
+{
+ UCHAR sign[SHA1_SIZE];
+ UCHAR sign2[SHA1_SIZE];
+ UCHAR *p;
+ UCHAR *iv;
+ UINT size;
+ UCHAR keygen[SHA1_SIZE * 2];
+ UCHAR key[SHA1_SIZE];
+ CRYPT *c;
+ UCHAR padlen;
+ UINT64 seq_no;
+ UCHAR *payload;
+ UINT payload_size;
+ // Validate arguments
+ if (r == NULL || se == NULL || recv_data == NULL || recv_size == 0 || se->BulkRecvKey == NULL)
+ {
+ return false;
+ }
+
+ p = (UCHAR *)recv_data;
+ size = recv_size;
+ if (size < SHA1_SIZE)
+ {
+ return false;
+ }
+
+ // Validate the signature
+ if (se->UseHMac == false)
+ {
+ Copy(sign, p, SHA1_SIZE);
+ Copy(p, se->BulkRecvKey->Data, SHA1_SIZE);
+ HashSha1(sign2, p, recv_size);
+ Copy(p, sign, SHA1_SIZE);
+
+ if (Cmp(sign, sign2, SHA1_SIZE) != 0)
+ {
+ HMacSha1(sign2, se->BulkRecvKey->Data, SHA1_SIZE, p + SHA1_SIZE, recv_size - SHA1_SIZE);
+
+ if (Cmp(p, sign2, SHA1_SIZE) != 0)
+ {
+ return false;
+ }
+ else
+ {
+ se->UseHMac = true;
+ }
+ }
+ else
+ {
+ }
+ }
+ else
+ {
+ HMacSha1(sign2, se->BulkRecvKey->Data, SHA1_SIZE, p + SHA1_SIZE, recv_size - SHA1_SIZE);
+
+ if (Cmp(p, sign2, SHA1_SIZE) != 0)
+ {
+ return false;
+ }
+ }
+
+ p += SHA1_SIZE;
+ size -= SHA1_SIZE;
+
+ // IV
+ if (size < SHA1_SIZE)
+ {
+ return false;
+ }
+ iv = p;
+ p += SHA1_SIZE;
+ size -= SHA1_SIZE;
+
+ // Decrypt
+ if (size < 1)
+ {
+ return false;
+ }
+ Copy(keygen + 0, se->BulkRecvKey->Data, SHA1_SIZE);
+ Copy(keygen + SHA1_SIZE, iv, SHA1_SIZE);
+ HashSha1(key, keygen, sizeof(keygen));
+
+ c = NewCrypt(key, sizeof(key));
+ Encrypt(c, p, p, size);
+ FreeCrypt(c);
+
+ // padlen
+ padlen = p[size - 1];
+ if (padlen == 0)
+ {
+ return false;
+ }
+ if (size < padlen)
+ {
+ return false;
+ }
+ size -= padlen;
+
+ // SEQ NO
+ seq_no = READ_UINT64(p);
+ p += sizeof(UINT64);
+ size -= sizeof(UINT64);
+
+ if (seq_no == 0 || seq_no >= (0xF000000000000000ULL))
+ {
+ // Sequence number is invalid
+ return false;
+ }
+
+ if ((seq_no + RUDP_BULK_SEQ_NO_RANGE) < se->BulkRecvSeqNoMax)
+ {
+ // Sequence number is too small
+ return false;
+ }
+
+ se->LastRecvTick = r->Now;
+
+ payload = p;
+ payload_size = size;
+
+ se->BulkRecvSeqNoMax = MAX(seq_no, se->BulkRecvSeqNoMax);
+
+ // Send the received bulk packet to the Tube of the socket
+ RUDPInitSock(r, se);
+
+ if (se->TcpSock != NULL)
+ {
+ SOCK *s = se->TcpSock;
+ TUBE *t = s->BulkSendTube;
+
+ if (t != NULL)
+ {
+ TubeSendEx2(t, payload, payload_size, NULL, true, RUDP_BULK_MAX_RECV_PKTS_IN_QUEUE);
+
+ se->FlushBulkSendTube = true;
+ }
+ }
+
+ return true;
+}
+
+// Process the received packet (segment)
+bool RUDPProcessRecvPacket(RUDP_STACK *r, RUDP_SESSION *se, void *recv_data, UINT recv_size)
+{
+ UCHAR sign[SHA1_SIZE];
+ UCHAR sign2[SHA1_SIZE];
+ UCHAR *p;
+ UCHAR *iv;
+ UINT size;
+ UCHAR keygen[SHA1_SIZE * 2];
+ UCHAR key[SHA1_SIZE];
+ CRYPT *c;
+ UCHAR padlen;
+ UINT num_ack;
+ UINT i;
+ UINT64 seq_no;
+ UCHAR *payload;
+ UINT payload_size;
+ UINT64 max_ack;
+ UINT64 my_tick, your_tick;
+ // Validate arguments
+ if (r == NULL || se == NULL || recv_data == NULL || recv_size == 0)
+ {
+ return false;
+ }
+
+ p = (UCHAR *)recv_data;
+ size = recv_size;
+ if (size < SHA1_SIZE)
+ {
+ return false;
+ }
+
+ // Validate the signature
+ Copy(sign, p, SHA1_SIZE);
+ Copy(p, se->Key_Recv, SHA1_SIZE);
+ HashSha1(sign2, p, recv_size);
+ Copy(p, sign, SHA1_SIZE);
+
+ if (r->Protocol == RUDP_PROTOCOL_DNS || r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ XorData(sign2, sign2, r->SvcNameHash, SHA1_SIZE);
+ }
+
+ if (Cmp(sign, sign2, SHA1_SIZE) != 0)
+ {
+ //WHERE;
+ return false;
+ }
+ p += SHA1_SIZE;
+ size -= SHA1_SIZE;
+
+ // IV
+ if (size < SHA1_SIZE)
+ {
+ return false;
+ }
+ iv = p;
+ p += SHA1_SIZE;
+ size -= SHA1_SIZE;
+
+ // Decrypt
+ if (size < 1)
+ {
+ return false;
+ }
+ Copy(keygen + 0, iv, SHA1_SIZE);
+ Copy(keygen + SHA1_SIZE, se->Key_Recv, SHA1_SIZE);
+ HashSha1(key, keygen, sizeof(keygen));
+
+ c = NewCrypt(key, sizeof(key));
+ Encrypt(c, p, p, size);
+ FreeCrypt(c);
+
+ // padlen
+ padlen = p[size - 1];
+ if (padlen == 0)
+ {
+ return false;
+ }
+ if (size < padlen)
+ {
+ return false;
+ }
+ size -= padlen;
+
+ // MyTick
+ if (size < sizeof(UINT64))
+ {
+ return false;
+ }
+ my_tick = READ_UINT64(p);
+ p += sizeof(UINT64);
+ size -= sizeof(UINT64);
+
+ // YourTick
+ if (size < sizeof(UINT64))
+ {
+ return false;
+ }
+ your_tick = READ_UINT64(p);
+ p += sizeof(UINT64);
+ size -= sizeof(UINT64);
+
+ if (your_tick > r->Now)
+ {
+ return false;
+ }
+
+ // MAX_ACK
+ if (size < sizeof(UINT64))
+ {
+ return false;
+ }
+ max_ack = READ_UINT64(p);
+ p += sizeof(UINT64);
+ size -= sizeof(UINT64);
+
+ // num_ack
+ if (size < sizeof(UINT))
+ {
+ return false;
+ }
+
+ num_ack = READ_UINT(p);
+ if (num_ack > RUDP_MAX_NUM_ACK)
+ {
+ return false;
+ }
+ p += sizeof(UINT);
+ size -= sizeof(UINT);
+
+ // ACKs
+ if (size < (sizeof(UINT64) * num_ack + sizeof(UINT64)))
+ {
+ return false;
+ }
+
+ if (max_ack >= 1)
+ {
+ RUDPProcessAck2(r, se, max_ack);
+ }
+
+ for (i = 0;i < num_ack;i++)
+ {
+ UINT64 seq = READ_UINT64(p);
+
+ RUDPProcessAck(r, se, seq);
+
+ p += sizeof(UINT64);
+ size -= sizeof(UINT64);
+ }
+
+ // Processing of the Tick (Calculation of RTT)
+ if (my_tick >= 2)
+ {
+ my_tick--;
+ }
+ se->YourTick = MAX(se->YourTick, my_tick);
+
+ se->LatestRecvMyTick = MAX(se->LatestRecvMyTick, your_tick);
+
+ if (se->LatestRecvMyTick2 != se->LatestRecvMyTick)
+ {
+ se->LatestRecvMyTick2 = se->LatestRecvMyTick;
+ se->CurrentRtt = (UINT)(r->Now - se->LatestRecvMyTick);
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("CurrentRTT = %u\n", se->CurrentRtt);
+#endif // RUDP_DETAIL_LOG
+ }
+
+ // SEQ NO
+ seq_no = READ_UINT64(p);
+ p += sizeof(UINT64);
+ size -= sizeof(UINT64);
+
+ if (seq_no == 0)
+ {
+ // Sequence number of 0 is a invalid packet
+ return true;
+ }
+
+ if (seq_no == se->Magic_Disconnect)
+ {
+ // Disconnected from opponent
+ RUDPDisconnectSession(r, se, true);
+ return true;
+ }
+
+ // Update the last reception date and time
+ se->LastRecvTick = r->Now;
+
+ payload = p;
+ payload_size = size;
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("RUDP %X Segment Recv: %I64u (num_ack=%u, size=%u)\n", se, seq_no, num_ack, size);
+#endif // RUDP_DETAIL_LOG
+
+ if (payload_size >= 1 && payload_size <= RUDP_MAX_SEGMENT_SIZE)
+ {
+ // Received one or more bytes of data
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("Recv Size: %X %I64u %u %u\n", se, seq_no, payload_size, recv_size);
+#endif // RUDP_DETAIL_LOG
+
+ RUDPProcessRecvPayload(r, se, seq_no, payload, payload_size);
+ }
+
+ if (r->ServerMode == false)
+ {
+ if (se->Status == RUDP_SESSION_STATUS_CONNECT_SENT)
+ {
+ // Shift to the established state if the connection is not yet in established state
+ se->Status = RUDP_SESSION_STATUS_ESTABLISHED;
+
+ RUDPInitSock(r, se);
+ }
+ }
+
+ return true;
+}
+
+// Disconnect the session
+void RUDPDisconnectSession(RUDP_STACK *r, RUDP_SESSION *se, bool disconnected_by_you)
+{
+ // Validate arguments
+ if (r == NULL || se == NULL)
+ {
+ return;
+ }
+
+ if (se->DisconnectFlag == false)
+ {
+ UINT i;
+
+ se->DisconnectFlag = true;
+ se->DisconnectedByYou = disconnected_by_you;
+
+ Debug("R-UDP Session %X Disconnected. by you flag: %u\n", se, disconnected_by_you);
+
+ if (se->TcpSock != NULL)
+ {
+ // Disconnect a TCP socket
+ Disconnect(se->TcpSock);
+ ReleaseSock(se->TcpSock);
+
+ se->TcpSock = NULL;
+ }
+
+ // Send 5 disconnect signals serially if to disconnect from here
+ if (disconnected_by_you == false)
+ {
+ for (i = 0;i < 5;i++)
+ {
+ RUDPSendSegmentNow(r, se, se->Magic_Disconnect, NULL, 0);
+ }
+ }
+ }
+}
+
+// Initialize the TCP socket for the session
+void RUDPInitSock(RUDP_STACK *r, RUDP_SESSION *se)
+{
+ SOCK *s1, *s2;
+ UINT mss;
+ // Validate arguments
+ if (r == NULL || se == NULL || se->DisconnectFlag)
+ {
+ return;
+ }
+
+ if (se->TcpSock != NULL)
+ {
+ // It has already been created
+ return;
+ }
+
+ // Creating a TCP socket pair
+ if (NewTcpPair(&s1, &s2) == false)
+ {
+ // Failed to create. Disconnect the session
+ RUDPDisconnectSession(r, se, false);
+ return;
+ }
+
+ // Calculate the optimal MSS
+ mss = RUDPCalcBestMssForBulk(r, se);
+
+ if (r->ServerMode)
+ {
+ // Server mode
+ se->TcpSock = s2;
+
+ JoinSockToSockEvent(s2, r->SockEvent);
+
+ // Update the end point information of the socket s1
+ ZeroIP4(&s1->LocalIP);
+ s1->LocalPort = se->MyPort;
+ Copy(&s1->RemoteIP, &se->YourIp, sizeof(IP));
+ s1->RemotePort = se->YourPort;
+ if (IsLocalHostIP(&s1->RemoteIP) == false)
+ {
+ AddIpClient(&s1->RemoteIP);
+ s1->IpClientAdded = true;
+ }
+ s1->IsRUDPSocket = true;
+
+ s1->BulkSendKey = se->BulkSendKey;
+ s1->BulkRecvKey = se->BulkRecvKey;
+
+ AddRef(s1->BulkSendKey->Ref);
+ AddRef(s1->BulkRecvKey->Ref);
+
+ s1->RUDP_OptimizedMss = mss;
+
+ // Enqueue the newly created socket, and set the event
+ InsertQueueWithLock(r->NewSockQueue, s1);
+ Set(r->NewSockConnectEvent);
+ }
+ else
+ {
+ // Client mode
+ Lock(r->Lock);
+ {
+ if (r->TargetConnectedSock == NULL && r->DoNotSetTargetConnectedSock == false)
+ {
+ // Update the end point information of the socket s2
+ Copy(&s2->LocalIP, &r->UdpSock->LocalIP, sizeof(IP));
+ s2->LocalPort = se->MyPort;
+ Copy(&s2->RemoteIP, &se->YourIp, sizeof(IP));
+ s2->RemotePort = se->YourPort;
+ if (IsLocalHostIP(&s2->RemoteIP) == false)
+ {
+ AddIpClient(&s2->RemoteIP);
+ s2->IpClientAdded = true;
+ }
+ s2->IsRUDPSocket = true;
+
+ s2->BulkSendKey = se->BulkSendKey;
+ s2->BulkRecvKey = se->BulkRecvKey;
+
+ AddRef(s2->BulkSendKey->Ref);
+ AddRef(s2->BulkRecvKey->Ref);
+
+ s2->RUDP_OptimizedMss = mss;
+
+ // Register the socket to the RUDP stack
+ r->TargetConnectedSock = s2;
+ s2->R_UDP_Stack = r;
+ se->TcpSock = s1;
+
+ JoinSockToSockEvent(s1, r->SockEvent);
+
+ // Set the event to be set when the connection is successful
+ Set(r->TargetConnectedEvent);
+ }
+ else
+ {
+ Disconnect(s1);
+ Disconnect(s2);
+ ReleaseSock(s1);
+ ReleaseSock(s2);
+ }
+ }
+ Unlock(r->Lock);
+ }
+}
+
+// Process the received payload
+void RUDPProcessRecvPayload(RUDP_STACK *r, RUDP_SESSION *se, UINT64 seq, void *payload_data, UINT payload_size)
+{
+ RUDP_SEGMENT t;
+ RUDP_SEGMENT *s;
+ // Validate arguments
+ if (r == NULL || se == NULL || seq == 0 || payload_data == NULL || payload_size == 0 || payload_size > RUDP_MAX_SEGMENT_SIZE)
+ {
+ return;
+ }
+
+ if (seq > (se->LastRecvCompleteSeqNo + RUDP_MAX_NUM_ACK))
+ {
+ // Ignore the segment which have sequence number beyond the window size, and also not to reply an ACK
+ return;
+ }
+
+ if (seq <= se->LastRecvCompleteSeqNo)
+ {
+ // Do not receive the segment which have the sequence number that has been already received. However, reply an ACK for it
+ AddInt64Distinct(se->ReplyAckList, seq);
+ return;
+ }
+
+ Zero(&t, sizeof(t));
+ t.SeqNo = seq;
+
+ s = Search(se->RecvSegmentList, &t);
+ if (s != NULL)
+ {
+ // Do not receive the segment which have the sequence number that has been already received. However, reply an ACK for it
+ AddInt64Distinct(se->ReplyAckList, seq);
+ return;
+ }
+
+ // Received a segment of the new sequence number
+ s = ZeroMalloc(sizeof(RUDP_SEGMENT));
+ s->SeqNo = seq;
+ Copy(s->Data, payload_data, payload_size);
+ s->Size = payload_size;
+ Insert(se->RecvSegmentList, s);
+
+ // Reply an ACK
+ AddInt64Distinct(se->ReplyAckList, seq);
+
+ // Create a socket for session if it have not been created yet
+ //RUDPInitSock(r, se);
+}
+
+// Process the incoming ACK
+void RUDPProcessAck(RUDP_STACK *r, RUDP_SESSION *se, UINT64 seq)
+{
+ RUDP_SEGMENT t;
+ RUDP_SEGMENT *s;
+ // Validate arguments
+ if (r == NULL || se == NULL || seq == 0)
+ {
+ return;
+ }
+
+ Zero(&t, sizeof(t));
+ t.SeqNo = seq;
+
+ s = Search(se->SendSegmentList, &t);
+ if (s == NULL)
+ {
+ return;
+ }
+
+ Delete(se->SendSegmentList, s);
+ Free(s);
+}
+
+// Remove all segments which are preceding max_seq as already delivered
+void RUDPProcessAck2(RUDP_STACK *r, RUDP_SESSION *se, UINT64 max_seq)
+{
+ LIST *o;
+ UINT i;
+ // Validate arguments
+ if (r == NULL || se == NULL || max_seq == 0)
+ {
+ return;
+ }
+
+ o = NULL;
+
+ for (i = 0;i < LIST_NUM(se->SendSegmentList);i++)
+ {
+ RUDP_SEGMENT *s = LIST_DATA(se->SendSegmentList, i);
+
+ if (s->SeqNo <= max_seq)
+ {
+ if (o == NULL)
+ {
+ o = NewListFast(NULL);
+ }
+
+ Add(o, s);
+ }
+ }
+
+ if (o != NULL)
+ {
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ RUDP_SEGMENT *s = LIST_DATA(o, i);
+
+ Delete(se->SendSegmentList, s);
+
+ Free(s);
+ }
+
+ ReleaseList(o);
+ }
+}
+
+// Get the minimum sequence number which is trying to send
+UINT64 RUDPGetCurrentSendingMinSeqNo(RUDP_SESSION *se)
+{
+ RUDP_SEGMENT *s;
+ // Validate arguments
+ if (se == NULL)
+ {
+ return 0;
+ }
+
+ if (LIST_NUM(se->SendSegmentList) == 0)
+ {
+ return 0;
+ }
+
+ s = LIST_DATA(se->SendSegmentList, 0);
+
+ return s->SeqNo;
+}
+
+// Get the maximum sequence number which is trying to send
+UINT64 RUDPGetCurrentSendingMaxSeqNo(RUDP_SESSION *se)
+{
+ RUDP_SEGMENT *s;
+ // Validate arguments
+ if (se == NULL)
+ {
+ return 0;
+ }
+
+ if (LIST_NUM(se->SendSegmentList) == 0)
+ {
+ return 0;
+ }
+
+ s = LIST_DATA(se->SendSegmentList, (LIST_NUM(se->SendSegmentList) - 1));
+
+ return s->SeqNo;
+}
+
+// R-UDP segment transmission
+void RUDPSendSegmentNow(RUDP_STACK *r, RUDP_SESSION *se, UINT64 seq_no, void *data, UINT size)
+{
+ UCHAR dst[RUDP_MAX_PACKET_SIZE];
+ UCHAR *p;
+ UCHAR *iv;
+ LIST *o = NULL;
+ UINT i;
+ UCHAR padlen;
+ UINT current_size;
+ UCHAR sign[SHA1_SIZE];
+ UCHAR key[SHA1_SIZE];
+ UCHAR keygen[SHA1_SIZE * 2];
+ CRYPT *c;
+ UINT next_iv_pos;
+ UINT num_ack;
+ UINT icmp_type = 0;
+ // Validate arguments
+ if (r == NULL || se == NULL || (size != 0 && data == NULL) || (size > RUDP_MAX_SEGMENT_SIZE))
+ {
+ return;
+ }
+
+ Zero(dst, sizeof(dst));
+ p = dst;
+
+ // SIGN
+ Copy(p, se->Key_Send, SHA1_SIZE);
+ p += SHA1_SIZE;
+
+ // IV
+ iv = p;
+ Copy(iv, se->NextIv, SHA1_SIZE);
+ p += SHA1_SIZE;
+
+ for (i = 0;i < MIN(LIST_NUM(se->ReplyAckList), RUDP_MAX_NUM_ACK);i++)
+ {
+ UINT64 *seq = LIST_DATA(se->ReplyAckList, i);
+
+ if (o == NULL)
+ {
+ o = NewListFast(NULL);
+ }
+
+ Add(o, seq);
+ }
+
+ // MyTick
+ WRITE_UINT64(p, r->Now);
+ p += sizeof(UINT64);
+
+ // YourTick
+ WRITE_UINT64(p, se->YourTick);
+ p += sizeof(UINT64);
+
+ // MAX_ACK
+ WRITE_UINT64(p, se->LastRecvCompleteSeqNo);
+ p += sizeof(UINT64);
+
+ // NUM_ACK
+ num_ack = LIST_NUM(o);
+ WRITE_UINT(p, num_ack);
+ p += sizeof(UINT);
+
+ if (o != NULL)
+ {
+ // ACK body
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ UINT64 *seq = LIST_DATA(o, i);
+
+ WRITE_UINT64(p, *seq);
+ p += sizeof(UINT64);
+
+ Delete(se->ReplyAckList, seq);
+
+ Free(seq);
+ }
+ ReleaseList(o);
+ }
+
+ // SEQ
+ WRITE_UINT64(p, seq_no);
+ p += sizeof(UINT64);
+
+ // data
+ Copy(p, data, size);
+ p += size;
+
+ // padding
+ padlen = Rand8();
+ padlen = MAX(padlen, 1);
+
+ for (i = 0;i < padlen;i++)
+ {
+ *p = padlen;
+ p++;
+ }
+
+ current_size = (UINT)(p - dst);
+
+ // Encrypt
+ Copy(keygen + 0, iv, SHA1_SIZE);
+ Copy(keygen + SHA1_SIZE, se->Key_Send, SHA1_SIZE);
+ HashSha1(key, keygen, sizeof(keygen));
+ c = NewCrypt(key, sizeof(key));
+ Encrypt(c, dst + SHA1_SIZE * 2, dst + SHA1_SIZE * 2, current_size - (SHA1_SIZE * 2));
+ FreeCrypt(c);
+
+ // Sign
+ HashSha1(sign, dst, current_size);
+ if (r->Protocol == RUDP_PROTOCOL_DNS || r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ XorData(sign, sign, r->SvcNameHash, SHA1_SIZE);
+ }
+ Copy(dst, sign, SHA1_SIZE);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ icmp_type = se->Icmp_Type;
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ icmp_type = se->Dns_TranId;
+ }
+ RUDPSendPacket(r, &se->YourIp, se->YourPort, dst, current_size, icmp_type);
+
+ if (size >= 1)
+ {
+ se->LastSentTick = r->Now;
+ }
+
+ // Next IV
+ next_iv_pos = Rand32() % (current_size - SHA1_SIZE);
+ Copy(se->NextIv, dst + next_iv_pos, SHA1_SIZE);
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("RUDP %X Segment Sent: %I64u (num_ack=%u, size=%u)\n", se, seq_no, num_ack, size);
+#endif // RUDP_DETAIL_LOG
+
+ if (size >= 1)
+ {
+#ifdef RUDP_DETAIL_LOG
+ Debug("Send Size: %X %I64u %u %u\n", se, seq_no, size, current_size);
+#endif // RUDP_DETAIL_LOG
+ }
+}
+
+// R-UDP segment transmission (only put into the queue)
+void RUDPSendSegment(RUDP_STACK *r, RUDP_SESSION *se, void *data, UINT size)
+{
+ RUDP_SEGMENT *s;
+ // Validate arguments
+ if (r == NULL || se == NULL || (size != 0 && data == NULL) || (size > RUDP_MAX_SEGMENT_SIZE))
+ {
+ return;
+ }
+
+ s = ZeroMalloc(sizeof(RUDP_SEGMENT));
+
+ Copy(s->Data, data, size);
+ s->Size = size;
+
+ s->SeqNo = se->NextSendSeqNo++;
+
+ Insert(se->SendSegmentList, s);
+}
+
+// Search for a session
+RUDP_SESSION *RUDPSearchSession(RUDP_STACK *r, IP *my_ip, UINT my_port, IP *your_ip, UINT your_port)
+{
+ RUDP_SESSION t;
+ RUDP_SESSION *se;
+ // Validate arguments
+ if (r == NULL || my_ip == NULL || your_ip == NULL)
+ {
+ return NULL;
+ }
+
+ Copy(&t.MyIp, my_ip, sizeof(IP));
+ t.MyPort = my_port;
+ Copy(&t.YourIp, your_ip, sizeof(IP));
+ t.YourPort = your_port;
+
+ se = Search(r->SessionList, &t);
+
+ return se;
+}
+
+// Release of the session
+void RUDPFreeSession(RUDP_SESSION *se)
+{
+ UINT i;
+ // Validate arguments
+ if (se == NULL)
+ {
+ return;
+ }
+
+ Debug("RUDPFreeSession %X\n", se);
+
+ for (i = 0;i < LIST_NUM(se->SendSegmentList);i++)
+ {
+ RUDP_SEGMENT *s = LIST_DATA(se->SendSegmentList, i);
+
+ Free(s);
+ }
+
+ ReleaseList(se->SendSegmentList);
+
+ for (i = 0;i < LIST_NUM(se->RecvSegmentList);i++)
+ {
+ RUDP_SEGMENT *s = LIST_DATA(se->RecvSegmentList, i);
+
+ Free(s);
+ }
+
+ ReleaseList(se->RecvSegmentList);
+
+ if (se->TcpSock != NULL)
+ {
+ Disconnect(se->TcpSock);
+ ReleaseSock(se->TcpSock);
+ }
+
+ ReleaseInt64List(se->ReplyAckList);
+
+ ReleaseFifo(se->RecvFifo);
+ ReleaseFifo(se->SendFifo);
+
+ ReleaseSharedBuffer(se->BulkSendKey);
+ ReleaseSharedBuffer(se->BulkRecvKey);
+
+ Free(se);
+}
+
+// Create a new session
+RUDP_SESSION *RUDPNewSession(bool server_mode, IP *my_ip, UINT my_port, IP *your_ip, UINT your_port, UCHAR *init_key)
+{
+ RUDP_SESSION *se;
+ UCHAR key1[SHA1_SIZE];
+ UCHAR key2[SHA1_SIZE];
+ UCHAR bulk_send_key[SHA1_SIZE];
+ UCHAR bulk_recv_key[SHA1_SIZE];
+ BUF *b;
+
+ se = ZeroMalloc(sizeof(RUDP_SESSION));
+
+ Copy(&se->MyIp, my_ip, sizeof(IP));
+ se->MyPort = my_port;
+
+ Copy(&se->YourIp, your_ip, sizeof(IP));
+ se->YourPort = your_port;
+
+ Copy(se->Key_Init, init_key, SHA1_SIZE);
+ se->LastSentTick = 0;
+ se->LastRecvTick = Tick64();
+ se->LatestRecvMyTick = Tick64();
+
+ se->NextSendSeqNo = 1;
+
+ se->ServerMode = server_mode;
+
+ se->SendSegmentList = NewList(RUDPCompareSegmentList);
+ se->RecvSegmentList = NewList(RUDPCompareSegmentList);
+
+ // Generate the two keys
+ b = NewBuf();
+ WriteBuf(b, init_key, SHA1_SIZE);
+ WriteBufStr(b, "zurukko");
+ HashSha1(key1, b->Buf, b->Size);
+ FreeBuf(b);
+
+ b = NewBuf();
+ WriteBuf(b, init_key, SHA1_SIZE);
+ WriteBuf(b, key1, SHA1_SIZE);
+ WriteBufStr(b, "yasushineko");
+ HashSha1(key2, b->Buf, b->Size);
+ FreeBuf(b);
+
+ // Generate the magic number for the KeepAlive
+ b = NewBuf();
+ WriteBuf(b, init_key, SHA1_SIZE);
+ WriteBufStr(b, "Magic_KeepAliveRequest");
+ HashSha1(se->Magic_KeepAliveRequest, b->Buf, b->Size);
+ FreeBuf(b);
+ b = NewBuf();
+ WriteBuf(b, init_key, SHA1_SIZE);
+ WriteBufStr(b, "Magic_KeepAliveResponse");
+ HashSha1(se->Magic_KeepAliveResponse, b->Buf, b->Size);
+ FreeBuf(b);
+
+ if (server_mode == false)
+ {
+ se->Magic_Disconnect = 0xffffffff00000000ULL | (UINT64)(Rand32());
+ }
+
+ Copy(se->Key_Init, init_key, SHA1_SIZE);
+
+ if (se->ServerMode)
+ {
+ Copy(se->Key_Send, key1, SHA1_SIZE);
+ Copy(se->Key_Recv, key2, SHA1_SIZE);
+ }
+ else
+ {
+ Copy(se->Key_Send, key2, SHA1_SIZE);
+ Copy(se->Key_Recv, key1, SHA1_SIZE);
+ }
+
+ Rand(se->NextIv, sizeof(se->NextIv));
+
+ se->ReplyAckList = NewInt64List(true);
+
+ se->NextKeepAliveInterval = RUDP_KEEPALIVE_INTERVAL_MIN + (Rand32() % (RUDP_KEEPALIVE_INTERVAL_MAX - RUDP_KEEPALIVE_INTERVAL_MIN));
+
+ se->RecvFifo = NewFifo();
+ se->SendFifo = NewFifo();
+
+ se->Dns_TranId = Rand16() % 65535 + 1;
+
+ // Generate the bulk transfer key
+ Rand(bulk_send_key, sizeof(bulk_send_key));
+ Rand(bulk_recv_key, sizeof(bulk_recv_key));
+
+ se->BulkSendKey = NewSharedBuffer(bulk_send_key, sizeof(bulk_send_key));
+ se->BulkRecvKey = NewSharedBuffer(bulk_recv_key, sizeof(bulk_recv_key));
+
+ Rand(se->BulkNextIv, sizeof(se->BulkNextIv));
+ se->BulkNextSeqNo = 1;
+
+ return se;
+}
+
+// Comparison function of the segment list items
+int RUDPCompareSegmentList(void *p1, void *p2)
+{
+ RUDP_SEGMENT *s1, *s2;
+ UINT r;
+ // Validate arguments
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ s1 = *((RUDP_SEGMENT **)p1);
+ s2 = *((RUDP_SEGMENT **)p2);
+ if (s1 == NULL || s2 == NULL)
+ {
+ return 0;
+ }
+
+ r = COMPARE_RET(s1->SeqNo, s2->SeqNo);
+
+ return r;
+}
+
+// Send a UDP packet
+void RUDPSendPacket(RUDP_STACK *r, IP *dest_ip, UINT dest_port, void *data, UINT size, UINT icmp_type)
+{
+ UDPPACKET *p;
+ // Validate arguments
+ if (r == NULL || dest_ip == NULL || dest_port == 0 || data == NULL || size == 0)
+ {
+ return;
+ }
+
+ p = NewUdpPacket(&r->UdpSock->LocalIP, r->UdpSock->LocalPort,
+ dest_ip, dest_port,
+ Clone(data, size), size);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP || r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // ICMP Type / DNS Tran ID
+ p->Type = icmp_type;
+ }
+
+ Add(r->SendPacketList, p);
+}
+
+// R-UDP main thread
+void RUDPMainThread(THREAD *thread, void *param)
+{
+ RUDP_STACK *r;
+ bool halt_flag = false;
+ // Validate arguments
+ if (thread == NULL || param == NULL)
+ {
+ return;
+ }
+
+ r = (RUDP_STACK *)param;
+
+ AddWaitThread(thread);
+ NoticeThreadInit(thread);
+
+ while (true)
+ {
+ UINT wait_interval;
+ UINT i;
+ UINT min_wait_interval;
+ UINT num_ignore_errors = 0;
+
+ r->Now = Tick64();
+
+ Lock(r->Lock);
+ {
+ Copy(&r->NatT_IP_Safe, &r->NatT_IP, sizeof(IP));
+ Copy(&r->My_Private_IP_Safe, &r->My_Private_IP, sizeof(IP));
+ }
+ Unlock(r->Lock);
+
+ // Receive the data from the UDP socket
+ while (true)
+ {
+ UINT ret;
+ IP ip_src;
+ UINT port_src;
+
+ ret = RecvFrom(r->UdpSock, &ip_src, &port_src, r->TmpBuf, sizeof(r->TmpBuf));
+
+ if (ret == SOCK_LATER)
+ {
+ // There is no packet more
+ break;
+ }
+ else if (ret != 0)
+ {
+ // Receive a Packet
+ bool ok = false;
+ UDPPACKET *p = NewUdpPacket(&ip_src, port_src,
+ &r->UdpSock->LocalIP, r->UdpSock->LocalPort,
+ Clone(r->TmpBuf, ret), ret);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // Analyse the incoming ICMP packet
+ UINT ip_header_size = GetIpHeaderSize(p->Data, p->Size);
+
+ if (ip_header_size >= sizeof(IPV4_HEADER))
+ {
+ if (p->Size >= (ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE))
+ {
+ IPV4_HEADER *ip_header = (IPV4_HEADER *)(((UCHAR *)p->Data) + 0);
+ 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))
+ {
+ UCHAR hash[SHA1_SIZE];
+
+ HashSha1(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));
+
+ if (Cmp(hash, ((UCHAR *)p->Data) + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO), SHA1_SIZE) == 0)
+ {
+ UCHAR *new_data;
+ 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
+ Copy(&p->SrcPort, echo_header, sizeof(UINT));
+ }
+
+ // Record the Type
+ p->Type = icmp_header->Type;
+
+ // Erase the header part
+ new_data_size = p->Size - (ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE);
+ new_data = Clone(((UCHAR *)p->Data) + ip_header_size + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE, new_data_size);
+ Free(p->Data);
+ p->Data = new_data;
+ p->Size = new_data_size;
+
+ ok = true;
+ }
+ }
+ }
+ }
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // Analyse the incoming DNS packet
+ UINT offset;
+
+ if (r->ServerMode == false)
+ {
+ offset = 42;
+ }
+ else
+ {
+ offset = 37;
+ }
+
+ if (p->Size > offset)
+ {
+ UCHAR *new_data;
+ UINT new_size = p->Size - offset;
+
+ p->Type = *((USHORT *)p->Data);
+
+ new_data = Clone(((UCHAR *)p->Data) + offset, new_size);
+
+ Free(p->Data);
+ p->Data = new_data;
+ p->Size = new_size;
+
+ ok = true;
+ }
+ }
+ else
+ {
+ // Don't do anything for ordinary UDP packet
+ ok = true;
+ }
+
+ if (ok)
+ {
+ // Process the received packet
+ RUDPRecvProc(r, p);
+
+ r->TotalPhysicalReceived += ret;
+ }
+
+ FreeUdpPacket(p);
+ }
+ else
+ {
+ if (r->UdpSock->IgnoreRecvErr)
+ {
+ // An ignorable reception error occurs
+ if ((num_ignore_errors++) >= MAX_NUM_IGNORE_ERRORS)
+ {
+ break;
+ }
+ }
+ else
+ {
+ // A non-ignorable reception error occurs
+ break;
+ }
+ }
+ }
+
+ // Call the interrupt notification callback function
+ if (r->ProcInterrupts != NULL)
+ {
+ r->ProcInterrupts(r);
+ }
+
+ RUDPInterruptProc(r);
+
+ // Send all packets in the transmission packet list
+ for (i = 0;i < LIST_NUM(r->SendPacketList);i++)
+ {
+ UDPPACKET *p = LIST_DATA(r->SendPacketList, i);
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP)
+ {
+ // In case of the ICMP protocol, assemble an ICMP header
+ UINT dst_size = sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE + p->Size;
+ UCHAR *dst_data = ZeroMalloc(dst_size);
+
+ ICMP_HEADER *icmp_header = (ICMP_HEADER *)dst_data;
+ ICMP_ECHO *icmp_echo = (ICMP_ECHO *)(dst_data + sizeof(ICMP_HEADER));
+ UCHAR *hash = dst_data + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO);
+ UCHAR *icmp_data = dst_data + sizeof(ICMP_HEADER) + sizeof(ICMP_ECHO) + SHA1_SIZE;
+
+ // Header
+ icmp_header->Type = (UCHAR)p->Type;
+ icmp_header->Code = 0;
+ icmp_header->Checksum = 0;
+
+ if (r->ServerMode)
+ {
+ // 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
+ {
+ // Use the fixed ICMP ID and SEQ NO on the client side
+ icmp_echo->Identifier = Endian16(r->Client_IcmpId);
+ icmp_echo->SeqNo = Endian16(r->Client_IcmpSeqNo);
+ }
+
+ // Data body
+ Copy(icmp_data, p->Data, p->Size);
+
+ // Hash
+ HashSha1(hash, icmp_data, p->Size);
+
+ // Checksum calculation
+ icmp_header->Checksum = IpChecksum(dst_data, dst_size);
+
+ // Replacement
+ Free(p->Data);
+ p->Data = dst_data;
+ p->Size = dst_size;
+ }
+ else if (r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ BUF *b = NewBuf();
+ // In case of over DNS protocol, assemble a header that conforms to the DNS protocol
+ if (r->ServerMode == false)
+ {
+ // DNS query header
+ USHORT us = Rand16() % 65535 + 1;
+ static UCHAR dns_query_header_1[] =
+ {
+ 0x01, 0x00, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x08,
+ };
+ static UCHAR dns_query_header_2[] =
+ {
+ 0x00, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0x29, 0x10,
+ 0x00, 0x00, 0x00, 0x80, 0x00,
+ };
+ UCHAR rand_data[4];
+ char rand_str[MAX_SIZE];
+
+ Rand(rand_data, sizeof(rand_data));
+ BinToStr(rand_str, sizeof(rand_str), rand_data, sizeof(rand_data));
+ StrLower(rand_str);
+
+ WriteBuf(b, &us, sizeof(USHORT));
+ WriteBuf(b, dns_query_header_1, sizeof(dns_query_header_1));
+ WriteBuf(b, rand_str, 8);
+ WriteBuf(b, dns_query_header_2, sizeof(dns_query_header_2));
+ us = Endian16((USHORT)p->Size);
+ WriteBuf(b, &us, sizeof(USHORT));
+ WriteBuf(b, p->Data, p->Size);
+ }
+ else
+ {
+ // DNS response header
+ USHORT us = p->Type;
+ UINT ui;
+ static UCHAR dns_response_header_1[] =
+ {
+ 0x81, 0x80, 0x00, 0x01, 0x00, 0x01, 0x00, 0x00,
+ 0x00, 0x00, 0x08,
+ };
+ static UCHAR dns_response_header_2[] =
+ {
+ 0x00, 0x00, 0x30, 0x00, 0x01,
+ 0xc0, 0x0c, 0x00, 0x30, 0x00, 0x01, 0x00, 0x00, 0xa4, 0x5b,
+ };
+ static UCHAR dns_response_header_3[] =
+ {
+ 0x01, 0x00, 0x03, 0x08,
+ };
+ UCHAR rand_data[4];
+ char rand_str[MAX_SIZE];
+
+ Rand(rand_data, sizeof(rand_data));
+ BinToStr(rand_str, sizeof(rand_str), rand_data, sizeof(rand_data));
+ StrLower(rand_str);
+
+ WriteBuf(b, &us, sizeof(USHORT));
+ WriteBuf(b, dns_response_header_1, sizeof(dns_response_header_1));
+ WriteBuf(b, rand_str, 8);
+ WriteBuf(b, dns_response_header_2, sizeof(dns_response_header_2));
+ us = Endian16((USHORT)(p->Size + 4));
+ WriteBuf(b, &us, sizeof(USHORT));
+ WriteBuf(b, dns_response_header_3, sizeof(dns_response_header_3));
+ WriteBuf(b, p->Data, p->Size);
+
+ ui = Rand16() % (60 * 60 * 12) + (60 * 60 * 12);
+ WRITE_UINT(((UCHAR *)b->Buf) + 0x20, ui);
+ }
+ Free(p->Data);
+ p->Data = b->Buf;
+ p->Size = b->Size;
+ Free(b);
+ }
+
+ SendTo(r->UdpSock, &p->DstIP, p->DestPort, p->Data, p->Size);
+
+ r->TotalPhysicalSent += p->Size;
+
+ FreeUdpPacket(p);
+ }
+ DeleteAll(r->SendPacketList);
+
+ if (r->Halt)
+ {
+ // If it is necessary to stop, stop it after cycling through a loop
+ if (halt_flag == false)
+ {
+ halt_flag = true;
+ continue;
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ // Rest the CPU until the next event
+ wait_interval = GetNextIntervalForInterrupt(r->Interrupt);
+ if (r->ServerMode)
+ {
+ min_wait_interval = RUDP_LOOP_WAIT_INTERVAL_S;
+ }
+ else
+ {
+ min_wait_interval = RUDP_LOOP_WAIT_INTERVAL_C;
+ }
+
+ if (wait_interval == INFINITE)
+ {
+ wait_interval = min_wait_interval;
+ }
+ else
+ {
+ wait_interval = MIN(min_wait_interval, wait_interval);
+ }
+
+#ifdef RUDP_DETAIL_LOG
+ Debug("wait_interval = %u\n", wait_interval);
+#endif // RUDP_DETAIL_LOG
+
+ if (wait_interval >= 1)
+ {
+ WaitSockEvent(r->SockEvent, wait_interval);
+ }
+
+#ifdef RUDP_DETAIL_LOG
+ if (r->ServerMode)
+ {
+ char str1[MAX_SIZE];
+ char str2[MAX_SIZE];
+ double rate = 0.0;
+
+ ToStr64(str1, r->TotalPhysicalReceived);
+ ToStr64(str2, r->TotalLogicalReceived);
+
+ if (r->TotalPhysicalReceived >= 1)
+ {
+ rate = (double)r->TotalLogicalReceived / (double)r->TotalPhysicalReceived;
+ }
+
+ Debug("%s / %s %.4f\n", str1, str2, rate);
+ }
+#endif // RUDP_DETAIL_LOG
+ }
+
+ Disconnect(r->UdpSock);
+
+ DelWaitThread(thread);
+}
+
+// Generate a appropriate register host name from the IP address
+void RUDPGetRegisterHostNameByIP(char *dst, UINT size, IP *ip)
+{
+ char tmp[16];
+ // Validate arguments
+ if (dst == NULL)
+ {
+ return;
+ }
+
+ if (ip != NULL && IsIP4(ip))
+ {
+ UCHAR hash[SHA1_SIZE];
+
+ HashSha1(hash, ip->addr, 4);
+ BinToStr(tmp, sizeof(tmp), hash, 2);
+ }
+ else
+ {
+ UCHAR rand[2];
+ Rand(rand, 2);
+ BinToStr(tmp, sizeof(tmp), rand, 2);
+ }
+
+ StrLower(tmp);
+ Format(dst, size,
+ (IsUseAlternativeHostname() ? UDP_NAT_T_SERVER_TAG_ALT : UDP_NAT_T_SERVER_TAG),
+ tmp[0], tmp[1], tmp[2], tmp[3]);
+
+
+ if (false)
+ {
+ Debug("Hash Src IP: %r\n"
+ "Hash Dst HN: %s\n",
+ ip,
+ dst);
+ }
+}
+
+// Analyze the IP address and port number from the string
+bool RUDPParseIPAndPortStr(void *data, UINT data_size, IP *ip, UINT *port)
+{
+ char tmp[MAX_SIZE];
+ UINT i;
+ char ipstr[MAX_SIZE];
+ char *portstr;
+ // Validate arguments
+ if (data == NULL || ip == NULL || port == NULL)
+ {
+ return false;
+ }
+
+ Zero(tmp, sizeof(tmp));
+
+ Copy(tmp, data, MIN(data_size, sizeof(tmp) - 1));
+
+ if (StartWith(tmp, "IP=") == false)
+ {
+ return false;
+ }
+
+ i = SearchStrEx(tmp, "#", 0, true);
+ if (i != INFINITE)
+ {
+ tmp[i] = 0;
+ }
+
+ StrCpy(ipstr, sizeof(ipstr), tmp + 3);
+
+ i = SearchStrEx(ipstr, ",PORT=", 0, true);
+ if (i == INFINITE)
+ {
+ return false;
+ }
+
+ ipstr[i] = 0;
+ portstr = ipstr + i + 6;
+
+ StrToIP(ip, ipstr);
+ *port = ToInt(portstr);
+
+ return true;
+}
+
+// R-UDP NAT-T IP address acquisition thread
+void RUDPIpQueryThread(THREAD *thread, void *param)
+{
+ RUDP_STACK *r;
+ UINT64 next_getip_tick = 0;
+ UINT64 next_getprivate_ip_tick = 0;
+ UINT last_ip_hash = 0;
+ void *route_change_poller = NULL;
+ char current_hostname[MAX_SIZE];
+ bool last_time_ip_changed = false;
+ // Validate arguments
+ if (thread == NULL || param == NULL)
+ {
+ return;
+ }
+
+ r = (RUDP_STACK *)param;
+
+ last_ip_hash = GetHostIPAddressHash32();
+
+ route_change_poller = NewRouteChange();
+ IsRouteChanged(route_change_poller);
+
+ Zero(current_hostname, sizeof(current_hostname));
+
+ while (r->Halt == false)
+ {
+ UINT ip_hash = GetHostIPAddressHash32();
+ UINT64 now = Tick64();
+ bool ip_changed = false;
+
+ if (ip_hash != last_ip_hash)
+ {
+ last_time_ip_changed = false;
+ }
+
+ if ((ip_hash != last_ip_hash) || (IsRouteChanged(route_change_poller)))
+ {
+ if (last_time_ip_changed == false)
+ {
+ // Call all getting functions from the beginning
+ // if the routing table or the IP address of this host has changed
+ next_getip_tick = 0;
+ next_getprivate_ip_tick = 0;
+ ip_changed = true;
+
+ last_ip_hash = ip_hash;
+
+ last_time_ip_changed = true;
+ }
+ }
+ else
+ {
+ last_time_ip_changed = false;
+ }
+
+ Lock(r->Lock);
+ {
+ if (StrCmpi(current_hostname, r->CurrentRegisterHostname) != 0)
+ {
+ // The target host name has changed
+ next_getip_tick = 0;
+ StrCpy(current_hostname, sizeof(current_hostname), r->CurrentRegisterHostname);
+ }
+ }
+ Unlock(r->Lock);
+
+ // Get the IP address of the NAT-T server with DNS
+ if (next_getip_tick == 0 || now >= next_getip_tick)
+ {
+ IP ip;
+
+ if (GetIP4(&ip, current_hostname) && IsZeroIp(&ip) == false)
+ {
+ Lock(r->Lock);
+ {
+// Debug("%r %r\n",&r->NatT_IP, &ip);
+ if (CmpIpAddr(&r->NatT_IP, &ip) != 0)
+ {
+// WHERE;
+ ip_changed = true;
+ Copy(&r->NatT_IP, &ip, sizeof(IP));
+ }
+ }
+ Unlock(r->Lock);
+ }
+
+ if (IsZeroIp(&r->NatT_IP))
+ {
+ next_getip_tick = now + (UINT64)UDP_NAT_T_GET_IP_INTERVAL;
+ }
+ else
+ {
+ next_getip_tick = now + (UINT64)UDP_NAT_T_GET_IP_INTERVAL_AFTER;
+ }
+
+ if (ip_changed)
+ {
+ Debug("NAT-T: NAT-T Server IP (%s): %r\n", current_hostname, &r->NatT_IP);
+
+ r->NatT_GetTokenNextTick = 0;
+ r->NatT_RegisterNextTick = 0;
+ r->NatT_GetTokenFailNum = 0;
+ r->NatT_RegisterFailNum = 0;
+
+ r->NatT_TranId = Rand64();
+
+ SetSockEvent(r->SockEvent);
+ }
+ }
+
+ // Get a private IP address of this host using TCP
+ if (next_getprivate_ip_tick == 0 || now >= next_getprivate_ip_tick)
+ {
+ IP ip;
+
+ if (GetMyPrivateIP(&ip))
+ {
+ Lock(r->Lock);
+ {
+ Copy(&r->My_Private_IP, &ip, sizeof(IP));
+ }
+ Unlock(r->Lock);
+ }
+
+ if (IsZeroIp(&r->My_Private_IP))
+ {
+ next_getprivate_ip_tick = now + (UINT64)UDP_NAT_T_GET_PRIVATE_IP_INTERVAL;
+ }
+ else
+ {
+ next_getprivate_ip_tick = now + (UINT64)GenRandInterval(UDP_NAT_T_GET_PRIVATE_IP_INTERVAL_AFTER_MIN, UDP_NAT_T_GET_PRIVATE_IP_INTERVAL_AFTER_MAX);
+ }
+
+ Debug("NAT-T: My Private IP: %r\n", &r->My_Private_IP);
+ }
+
+ if (r->Halt)
+ {
+ break;
+ }
+
+ Wait(r->HaltEvent, RUDP_LOOP_WAIT_INTERVAL_S);
+ }
+
+ FreeRouteChange(route_change_poller);
+}
+
+// Generate a random intervals
+UINT GenRandInterval(UINT min, UINT max)
+{
+ UINT a, b;
+
+ a = MIN(min, max);
+ b = MAX(min, max);
+
+ if (a == b)
+ {
+ return a;
+ }
+
+ return (Rand32() % (b - a)) + a;
+}
+
+// Identify the private IP of the interface which is used to connect to the Internet currently
+bool GetMyPrivateIP(IP *ip)
+{
+ SOCK *s;
+ IP t;
+ char *hostname = UDP_NAT_T_GET_PRIVATE_IP_TCP_SERVER;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if (IsUseAlternativeHostname())
+ {
+ hostname = UDP_NAT_T_GET_PRIVATE_IP_TCP_SERVER_ALT;
+ }
+
+ s = ConnectEx(hostname, UDP_NAT_T_PORT_FOR_TCP_1, UDP_NAT_T_GET_PRIVATE_IP_CONNECT_TIMEOUT);
+
+ if (s == NULL)
+ {
+ s = ConnectEx(hostname, UDP_NAT_T_PORT_FOR_TCP_2, UDP_NAT_T_GET_PRIVATE_IP_CONNECT_TIMEOUT);
+
+ if (s == NULL)
+ {
+ s = ConnectEx(hostname, UDP_NAT_T_PORT_FOR_TCP_3, UDP_NAT_T_GET_PRIVATE_IP_CONNECT_TIMEOUT);
+
+ if (s == NULL)
+ {
+ return false;
+ }
+ }
+ }
+
+ Copy(&t, &s->LocalIP, sizeof(IP));
+
+ Disconnect(s);
+ ReleaseSock(s);
+
+ if (IsZeroIp(&t))
+ {
+ return false;
+ }
+
+ Copy(ip, &t, sizeof(IP));
+
+ return true;
+}
+
+// Function to wait until changing any IP address of the host or expiring the specified time or waking the event
+void WaitUntilHostIPAddressChanged(void *p, EVENT *event, UINT timeout, UINT ip_check_interval)
+{
+ UINT64 start, end;
+ UINT last_hash;
+ // Validate arguments
+ if (timeout == 0x7FFFFFFF)
+ {
+ timeout = 0xFFFFFFFF;
+ }
+ if (ip_check_interval == 0)
+ {
+ ip_check_interval = 0xFFFFFFFF;
+ }
+ if (event == NULL || timeout == 0)
+ {
+ return;
+ }
+
+ start = Tick64();
+ end = start + (UINT64)timeout;
+ last_hash = GetHostIPAddressHash32();
+
+ while (true)
+ {
+ UINT64 now = Tick64();
+ UINT next_interval;
+
+ if (now >= end)
+ {
+ break;
+ }
+
+ if (p != NULL)
+ {
+ if (IsRouteChanged(p))
+ {
+ break;
+ }
+ }
+
+ if (last_hash != GetHostIPAddressHash32())
+ {
+ break;
+ }
+
+ next_interval = (UINT)(end - now);
+ next_interval = MIN(next_interval, ip_check_interval);
+
+ if (Wait(event, next_interval))
+ {
+ break;
+ }
+ }
+}
+void *InitWaitUntilHostIPAddressChanged()
+{
+ void *p = NewRouteChange();
+
+ if (p != NULL)
+ {
+ IsRouteChanged(p);
+ }
+
+ return p;
+}
+void FreeWaitUntilHostIPAddressChanged(void *p)
+{
+ FreeRouteChange(p);
+}
+
+// Get whether the specified IPv6 address is on the local network
+bool IsIPv6LocalNetworkAddress(IP *ip)
+{
+ UINT type;
+ LIST *o;
+ UINT i;
+ bool ret = false;
+ IP mask64;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+ if (IsIP6(ip) == false)
+ {
+ return false;
+ }
+ if (IsZeroIp(ip))
+ {
+ return false;
+ }
+
+ type = GetIPAddrType6(ip);
+
+ if (type & IPV6_ADDR_LOCAL_UNICAST)
+ {
+ return true;
+ }
+
+ if ((type & IPV6_ADDR_GLOBAL_UNICAST) == 0)
+ {
+ return false;
+ }
+
+ IntToSubnetMask6(&mask64, 64);
+
+ o = GetHostIPAddressList();
+
+ ret = false;
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *p = LIST_DATA(o, i);
+
+ if (IsIP6(p))
+ {
+ if (IsZeroIp(p) == false)
+ {
+ if (IsLocalHostIP6(p) == false)
+ {
+ if (IsInSameNetwork6(p, ip, &mask64))
+ {
+ ret = true;
+ }
+ }
+ }
+ }
+ }
+
+ FreeHostIPAddressList(o);
+
+ return ret;
+}
+
+// Check whether the specified IP address is localhost or the IP address of the local interface of itself
+bool IsIPLocalHostOrMySelf(IP *ip)
+{
+ LIST *o;
+ bool ret = false;
+ UINT i;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ o = GetHostIPAddressList();
+ if (o == NULL)
+ {
+ return false;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *p = LIST_DATA(o, i);
+
+ if (CmpIpAddr(p, ip) == 0)
+ {
+ ret = true;
+
+ break;
+ }
+ }
+
+ FreeHostIPAddressList(o);
+
+ if (IsLocalHostIP4(ip) || IsLocalHostIP6(ip))
+ {
+ ret = true;
+ }
+
+ return ret;
+}
+
+// Get the results of the port number that is determined at random
+UINT RUDPGetRandPortNumber(UCHAR rand_port_id)
+{
+ UINT ret;
+ // Validate arguments
+ if (rand_port_id == 0)
+ {
+ return 0;
+ }
+
+ ret = rand_port_numbers[rand_port_id];
+
+ Debug("rand_port_id[%u] = %u\n", rand_port_id, ret);
+ return ret;
+}
+
+// Obtain the hash value of combining all of the IP address assigned to the host
+UINT GetHostIPAddressHash32()
+{
+ BUF *b;
+ UINT i;
+ UCHAR hash[SHA1_SIZE];
+ UINT ret;
+ LIST *o = GetHostIPAddressList();
+
+ if (o == NULL)
+ {
+ return 0;
+ }
+
+ b = NewBuf();
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *ip = LIST_DATA(o, i);
+
+ WriteBuf(b, ip, sizeof(IP));
+
+ WriteBufStr(b, ":-) yas (-:");
+ }
+ FreeHostIPAddressList(o);
+
+ WriteBuf(b, rand_port_numbers, sizeof(rand_port_numbers));
+
+ HashSha1(hash, b->Buf, b->Size);
+
+ FreeBuf(b);
+
+ Copy(&ret, hash, sizeof(UINT));
+
+ return ret;
+}
+
+// Create an IPv4 UDP socket destined for a particular target
+SOCK *NewUDP4ForSpecificIp(IP *target_ip, UINT port)
+{
+ SOCK *s;
+ IP local_ip;
+ // Validate arguments
+ if (target_ip == NULL || IsZeroIP(target_ip) || IsIP4(target_ip) == false)
+ {
+ target_ip = NULL;
+ }
+
+ Zero(&local_ip, sizeof(local_ip));
+ GetBestLocalIpForTarget(&local_ip, target_ip);
+
+ s = NewUDP4(port, &local_ip);
+
+ if (s == NULL)
+ {
+ s = NewUDP4(port, NULL);
+ }
+
+ return s;
+}
+
+// Get the best self IPv4 address to connect to the target IPv4 address
+bool GetBestLocalIpForTarget(IP *local_ip, IP *target_ip)
+{
+ bool ret = false;
+ ROUTE_ENTRY *e;
+ IP ip2;
+ UINT n = 0;
+ IP zero_ip;
+ // Validate arguments
+ Zero(local_ip, sizeof(IP));
+ ZeroIP4(&zero_ip);
+ if (target_ip == NULL)
+ {
+ target_ip = &zero_ip;
+ }
+ if (local_ip == NULL || IsIP4(target_ip) == false)
+ {
+ return false;
+ }
+
+ Copy(&ip2, target_ip, sizeof(IP));
+
+ while (true)
+ {
+ n++;
+ if (n >= 64)
+ {
+ break;
+ }
+
+ e = GetBestRouteEntry(&ip2);
+ if (e != NULL)
+ {
+ if (IsZeroIp(&e->GatewayIP))
+ {
+ Free(e);
+ break;
+ }
+
+ if (e->LocalRouting)
+ {
+ ret = true;
+ Copy(local_ip, &e->GatewayIP, sizeof(IP));
+ Free(e);
+ break;
+ }
+ else
+ {
+ Copy(&ip2, &e->GatewayIP, sizeof(IP));
+ }
+
+ Free(e);
+ }
+ }
+
+ if (ret == false)
+ {
+ if (IsLocalHostIP4(target_ip))
+ {
+ GetLocalHostIP4(local_ip);
+ ret = true;
+ }
+ }
+
+ return ret;
+}
+
+// Create a R-UDP client (Connection via NAT-T gateway)
+SOCK *NewRUDPClientNatT(char *svc_name, IP *ip, UINT *error_code, UINT timeout, bool *cancel, char *hint_str, char *target_hostname)
+{
+ IP nat_t_ip;
+ UINT dummy_int = 0;
+ UINT64 giveup_tick;
+ bool dummy_bool = false;
+ SOCK_EVENT *sock_event;
+ SOCK *sock;
+ bool same_lan = false;
+ char hostname[MAX_SIZE];
+ if (timeout == 0)
+ {
+ timeout = RUDP_TIMEOUT;
+ }
+ if (error_code == NULL)
+ {
+ error_code = &dummy_int;
+ }
+ if (cancel == NULL)
+ {
+ cancel = &dummy_bool;
+ }
+ *error_code = RUDP_ERROR_UNKNOWN;
+ if (svc_name == NULL || ip == NULL)
+ {
+ return NULL;
+ }
+
+ ListenTcpForPopupFirewallDialog();
+
+ giveup_tick = Tick64() + (UINT64)timeout;
+
+ // Get the IP address of the NAT-T server
+ RUDPGetRegisterHostNameByIP(hostname, sizeof(hostname), ip);
+ if (GetIP4Ex(&nat_t_ip, hostname, 0, cancel) == false)
+ {
+ *error_code = RUDP_ERROR_NAT_T_NO_RESPONSE;
+ return NULL;
+ }
+
+ if (Tick64() >= giveup_tick)
+ {
+ *error_code = RUDP_ERROR_TIMEOUT;
+ return NULL;
+ }
+ if (*cancel)
+ {
+ *error_code = RUDP_ERROR_USER_CANCELED;
+ return NULL;
+ }
+
+ sock = NewUDP4ForSpecificIp(&nat_t_ip, 0);
+ if (sock == NULL)
+ {
+ *error_code = RUDP_ERROR_UNKNOWN;
+ return NULL;
+ }
+ else
+ {
+ UINT64 next_send_request_tick = 0;
+ INTERRUPT_MANAGER *interrupt = NewInterruptManager();
+ UINT64 tran_id = Rand64();
+ UINT tmp_size = 65536;
+ UCHAR *tmp = Malloc(tmp_size);
+ char result_ip_str[MAX_SIZE];
+ IP result_ip;
+ UINT result_port;
+ SOCK *ret = NULL;
+ UINT num_tries = 0;
+
+ AddInterrupt(interrupt, giveup_tick);
+
+ sock_event = NewSockEvent();
+ JoinSockToSockEvent(sock, sock_event);
+
+ // Communication with the NAT-T server
+ while (true)
+ {
+ UINT64 now = Tick64();
+ UINT interval;
+ UINT r;
+ IP src_ip;
+ UINT src_port;
+ UINT err;
+ UINT num_ignore_errors = 0;
+
+ if (now >= giveup_tick)
+ {
+ // Time-out
+LABEL_TIMEOUT:
+ *error_code = RUDP_ERROR_NAT_T_NO_RESPONSE;
+ break;
+ }
+
+ if (*cancel)
+ {
+ // User canceled
+ *error_code = RUDP_ERROR_USER_CANCELED;
+ break;
+ }
+
+ err = INFINITE;
+
+ // Receive a response packet from the NAT-T server
+ while (err == INFINITE)
+ {
+ r = RecvFrom(sock, &src_ip, &src_port, tmp, tmp_size);
+ if (r == SOCK_LATER)
+ {
+ // No packet
+ break;
+ }
+ else if (r == 0)
+ {
+ if (sock->IgnoreRecvErr == false)
+ {
+ // Communication error
+ goto LABEL_TIMEOUT;
+ }
+ else
+ {
+ if ((num_ignore_errors++) >= MAX_NUM_IGNORE_ERRORS)
+ {
+ goto LABEL_TIMEOUT;
+ }
+ }
+ }
+ else
+ {
+ // Check the source IP address and the port number
+ if (CmpIpAddr(&src_ip, &nat_t_ip) == 0 && src_port == UDP_NAT_T_PORT)
+ {
+ BUF *b = NewBuf();
+ PACK *p;
+
+ WriteBuf(b, tmp, r);
+ SeekBuf(b, 0, 0);
+
+ p = BufToPack(b);
+
+ if (p != NULL)
+ {
+ // Compare tran_id
+ if (PackGetInt64(p, "tran_id") == tran_id)
+ {
+ // Compare opcode
+ if (PackCmpStr(p, "opcode", "nat_t_connect_request"))
+ {
+ bool ok = PackGetBool(p, "ok");
+ bool multi_candidate = PackGetBool(p, "multi_candidates");
+
+ if (ok)
+ {
+ // Success
+ PackGetStr(p, "result_ip", result_ip_str, sizeof(result_ip_str));
+ StrToIP(&result_ip, result_ip_str);
+
+ result_port = PackGetInt(p, "result_port");
+
+ same_lan = PackGetBool(p, "same_lan");
+
+ if (result_port != 0)
+ {
+ if (IsZeroIp(&result_ip) == false)
+ {
+ if ((sock->IPv6 == false && IsIP4(&result_ip)) ||
+ (sock->IPv6 && IsIP6(&result_ip)))
+ {
+ err = RUDP_ERROR_OK;
+ }
+ }
+ }
+ }
+ else if (multi_candidate)
+ {
+ // There are two or more computers behind the specified IP address
+ err = RUDP_ERROR_NAT_T_TWO_OR_MORE;
+ }
+ else
+ {
+ // Failure
+ err = RUDP_ERROR_NAT_T_NOT_FOUND;
+ }
+ }
+ }
+
+ FreePack(p);
+ }
+
+ FreeBuf(b);
+ }
+ }
+ }
+
+ if (err != INFINITE)
+ {
+ *error_code = err;
+ break;
+ }
+
+ if (next_send_request_tick == 0 || now >= next_send_request_tick)
+ {
+ // Send a connection request to the NAT-T server
+ BUF *b;
+ char ip_str[MAX_SIZE];
+ PACK *p = NewPack();
+
+ PackAddStr(p, "opcode", "nat_t_connect_request");
+ PackAddInt64(p, "tran_id", tran_id);
+ IPToStr(ip_str, sizeof(ip_str), ip);
+ PackAddStr(p, "dest_ip", ip_str);
+ if (IsEmptyStr(hint_str) == false)
+ {
+ PackAddStr(p, "hint", hint_str);
+ }
+ if (IsEmptyStr(target_hostname) == false)
+ {
+ PackAddStr(p, "target_hostname", target_hostname);
+ }
+ PackAddStr(p, "svc_name", svc_name);
+
+ PackAddInt(p, "nat_traversal_version", UDP_NAT_TRAVERSAL_VERSION);
+
+ b = PackToBuf(p);
+ FreePack(p);
+ SendTo(sock, &nat_t_ip, UDP_NAT_T_PORT, b->Buf, b->Size);
+ FreeBuf(b);
+
+ // Determine the next transmission time
+ next_send_request_tick = now + (UINT64)UDP_NAT_T_CONNECT_INTERVAL * (UINT64)(Power(2, MAX(num_tries, 6)));
+ num_tries++;
+ AddInterrupt(interrupt, next_send_request_tick);
+ }
+
+ interval = GetNextIntervalForInterrupt(interrupt);
+ interval = MIN(interval, 50);
+
+ WaitSockEvent(sock_event, interval);
+ }
+
+ Free(tmp);
+ FreeInterruptManager(interrupt);
+
+ if (*error_code == RUDP_ERROR_OK)
+ {
+ UINT remain_timeout;
+ UINT64 now = Tick64();
+ // Success to get the IP address and the port number of the target
+
+ // Get the rest timeout tolerance
+ if (now <= giveup_tick)
+ {
+ remain_timeout = (UINT)(giveup_tick - now);
+ }
+ else
+ {
+ remain_timeout = 0;
+ }
+
+ remain_timeout = MAX(remain_timeout, 2000);
+
+ if (same_lan)
+ {
+ // Discard current UDP socket and create a new UDP socket in NewRUDPClientDirect().
+ // Because using a UDP socket which used for communication with the NAT-T server
+ // can cause trouble when the client and the server exists in the same LAN.
+ ReleaseSockEvent(sock_event);
+ ReleaseSock(sock);
+
+ sock = NULL;
+ sock_event = NULL;
+ }
+
+ ret = NewRUDPClientDirect(svc_name, &result_ip, result_port, error_code, remain_timeout, cancel,
+ sock, sock_event, 0, false);
+ }
+
+ if (sock_event != NULL)
+ {
+ ReleaseSockEvent(sock_event);
+ }
+
+ if (sock != NULL)
+ {
+ ReleaseSock(sock);
+ }
+
+ return ret;
+ }
+}
+
+// Listen to the TCP for a moment to show the firewall dialog
+void ListenTcpForPopupFirewallDialog()
+{
+#ifdef OS_WIN32
+ static bool tried = false;
+
+ if (tried == false)
+ {
+ SOCK *s;
+ tried = true;
+ s = ListenAnyPortEx2(false, true);
+
+ if (s != NULL)
+ {
+ Disconnect(s);
+ ReleaseSock(s);
+ }
+ }
+#endif // OS_WIN32
+}
+
+// Create a R-UDP client (direct connection)
+SOCK *NewRUDPClientDirect(char *svc_name, IP *ip, UINT port, UINT *error_code, UINT timeout, bool *cancel, SOCK *sock, SOCK_EVENT *sock_event, UINT local_port, bool over_dns_mode)
+{
+ RUDP_STACK *r;
+ UINT dummy_int = 0;
+ SOCK *ret = NULL;
+ // Validate arguments
+ if (error_code == NULL)
+ {
+ error_code = &dummy_int;
+ }
+ if (timeout == 0)
+ {
+ timeout = RUDP_TIMEOUT;
+ }
+ *error_code = RUDP_ERROR_UNKNOWN;
+ if (svc_name == NULL || ip == NULL || port == 0)
+ {
+ return NULL;
+ }
+
+ r = NewRUDP(false, svc_name, NULL, NULL, NULL, local_port, sock, sock_event, false, over_dns_mode, ip, NULL, 0);
+ if (r == NULL)
+ {
+ *error_code = RUDP_ERROR_UNKNOWN;
+ return NULL;
+ }
+
+ // Set the port number and the target IP address
+ Lock(r->Lock);
+ {
+ Copy(&r->TargetIp, ip, sizeof(IP));
+ r->TargetPort = port;
+ r->TargetIpAndPortInited = true;
+ }
+ Unlock(r->Lock);
+ SetSockEvent(r->SockEvent);
+
+ // Wait for a connection success/failure to the target IP address
+ WaitEx(r->TargetConnectedEvent, timeout, cancel);
+ Lock(r->Lock);
+ {
+ if (r->TargetConnectedSock != NULL)
+ {
+ // The connection succeeded
+ ret = r->TargetConnectedSock;
+ r->TargetConnectedSock = NULL;
+ }
+ else
+ {
+ r->DoNotSetTargetConnectedSock = true;
+ }
+ }
+ Unlock(r->Lock);
+
+ if (ret == NULL)
+ {
+ // Stop the R-UDP stack if the connection has failed
+ *error_code = RUDP_ERROR_TIMEOUT;
+ FreeRUDP(r);
+ }
+ else if (cancel != NULL && (*cancel))
+ {
+ // User canceled
+ *error_code = RUDP_ERROR_USER_CANCELED;
+
+ Disconnect(ret);
+ ReleaseSock(ret);
+
+ ret = NULL;
+ }
+ else
+ {
+ *error_code = RUDP_ERROR_OK;
+ }
+
+ return ret;
+}
+
+// Creating a R-UDP server
+RUDP_STACK *NewRUDPServer(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)
+{
+ RUDP_STACK *r;
+ // Validate arguments
+ if (IsEmptyStr(svc_name))
+ {
+ return NULL;
+ }
+
+ if (g_no_rudp_server)
+ {
+ return NULL;
+ }
+
+ ListenTcpForPopupFirewallDialog();
+
+ r = NewRUDP(true, svc_name, proc_interrupts, proc_rpc_recv, param, port, NULL, NULL, no_natt_register, over_dns_mode, NULL, natt_global_udp_port, rand_port_id);
+
+ if (r == NULL)
+ {
+ return NULL;
+ }
+
+ return r;
+}
+
+// Creating a R-UDP
+RUDP_STACK *NewRUDP(bool server_mode, char *svc_name, RUDP_STACK_INTERRUPTS_PROC *proc_interrupts, RUDP_STACK_RPC_RECV_PROC *proc_rpc_recv, void *param, UINT port, SOCK *sock, SOCK_EVENT *sock_event, bool server_no_natt_register, bool over_dns_mode, IP *client_target_ip, volatile UINT *natt_global_udp_port, UCHAR rand_port_id)
+{
+ RUDP_STACK *r;
+ char tmp[MAX_SIZE];
+ UCHAR pid_hash[SHA1_SIZE];
+ UINT pid;
+ USHORT pid_us;
+
+ // Validate arguments
+ if (IsEmptyStr(svc_name))
+ {
+ return NULL;
+ }
+
+ ListenTcpForPopupFirewallDialog();
+
+ if (sock == NULL)
+ {
+ if (server_mode == false && client_target_ip != NULL)
+ {
+ sock = NewUDP4ForSpecificIp(client_target_ip, port);
+ }
+ else
+ {
+ if (rand_port_id == 0)
+ {
+ sock = NewUDP(port);
+ }
+ else
+ {
+ sock = NewUDPEx2RandMachineAndExePath(false, NULL, 0, rand_port_id);
+ }
+ }
+
+ if (sock == NULL)
+ {
+ return NULL;
+ }
+ }
+ else
+ {
+ AddRef(sock->ref);
+ }
+
+ if (port == 0)
+ {
+ port = sock->LocalPort;
+ }
+
+ if (rand_port_id != 0)
+ {
+ rand_port_numbers[rand_port_id] = port;
+ }
+
+ if (sock_event == NULL)
+ {
+ sock_event = NewSockEvent();
+ }
+ else
+ {
+ AddRef(sock_event->ref);
+ }
+
+ r = ZeroMalloc(sizeof(RUDP_STACK));
+
+ StrCpy(r->SvcName, sizeof(r->SvcName), svc_name);
+ r->RandPortId = rand_port_id;
+ r->NatTGlobalUdpPort = natt_global_udp_port;
+ r->ServerMode = server_mode;
+ r->Interrupt = NewInterruptManager();
+ r->SessionList = NewList(RUDPCompareSessionList);
+ r->UdpSock = sock;
+ r->Port = port;
+ r->SockEvent = sock_event;
+ r->HaltEvent = NewEvent();
+ r->Now = Tick64();
+ r->Lock = NewLock();
+ r->Param = param;
+ r->TargetConnectedEvent = NewEvent();
+ r->SendPacketList = NewList(NULL);
+ r->NewSockConnectEvent = NewEvent();
+ r->NewSockQueue = NewQueue();
+ r->NatT_TranId = Rand64();
+
+ StrCpy(tmp, sizeof(tmp), r->SvcName);
+ Trim(tmp);
+ StrLower(tmp);
+
+ HashSha1(r->SvcNameHash, tmp, StrLen(tmp));
+
+ r->Client_IcmpId = (USHORT)(Rand32() % 65534 + 1);
+ r->Client_IcmpSeqNo = (USHORT)(Rand32() % 65534 + 1);
+
+ // Determination of the type of the protocol
+ r->Protocol = RUDP_PROTOCOL_UDP;
+ if (r->Port == MAKE_SPECIAL_PORT(IP_PROTO_ICMPV4))
+ {
+ r->Protocol = RUDP_PROTOCOL_ICMP;
+
+ // Generate the ICMP ID based on the process ID
+#ifdef OS_WIN32
+ pid = (UINT)MsGetProcessId();
+#else // OS_WIN32
+ pid = (UINT)getpid();
+#endif // OS_WIN32
+
+ pid = Endian32(pid);
+ HashSha1(pid_hash, &pid, sizeof(UINT));
+
+ pid_us = READ_USHORT(pid_hash);
+ if (pid_us == 0 || pid_us == 0xFFFF)
+ {
+ pid_us = 1;
+ }
+
+ r->Client_IcmpId = pid_us;
+ }
+ else if (over_dns_mode)
+ {
+ r->Protocol = RUDP_PROTOCOL_DNS;
+ }
+
+ if (r->ServerMode)
+ {
+ r->NoNatTRegister = server_no_natt_register;
+
+ if (r->Protocol == RUDP_PROTOCOL_ICMP || r->Protocol == RUDP_PROTOCOL_DNS)
+ {
+ // Never register to the NAT-T server in case of using the DNS or the ICMP
+ r->NoNatTRegister = true;
+ }
+ }
+
+ RUDPGetRegisterHostNameByIP(r->CurrentRegisterHostname, sizeof(r->CurrentRegisterHostname), NULL);
+
+ if (r->ServerMode)
+ {
+ r->ProcInterrupts = proc_interrupts;
+ r->ProcRpcRecv = proc_rpc_recv;
+ }
+
+ if (r->ServerMode && r->NoNatTRegister == false)
+ {
+ r->IpQueryThread = NewThread(RUDPIpQueryThread, r);
+ }
+
+ JoinSockToSockEvent(r->UdpSock, r->SockEvent);
+
+ r->Thread = NewThread(RUDPMainThread, r);
+ WaitThreadInit(r->Thread);
+
+ return r;
+}
+
+// R-UDP session comparison function
+int RUDPCompareSessionList(void *p1, void *p2)
+{
+ RUDP_SESSION *s1, *s2;
+ UINT r;
+ // Validate arguments
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ s1 = *((RUDP_SESSION **)p1);
+ s2 = *((RUDP_SESSION **)p2);
+ if (s1 == NULL || s2 == NULL)
+ {
+ return 0;
+ }
+
+ r = CmpIpAddr(&s1->YourIp, &s2->YourIp);
+ if (r != 0)
+ {
+ return r;
+ }
+
+ r = COMPARE_RET(s1->YourPort, s2->YourPort);
+ if (r != 0)
+ {
+ return r;
+ }
+
+ r = CmpIpAddr(&s1->MyIp, &s2->MyIp);
+ if (r != 0)
+ {
+ return r;
+ }
+
+ r = COMPARE_RET(s1->MyPort, s2->MyPort);
+ if (r != 0)
+ {
+ return r;
+ }
+
+ return 0;
+}
+
+// Release of the R-UDP
+void FreeRUDP(RUDP_STACK *r)
+{
+ UINT i;
+ // Validate arguments
+ if (r == NULL)
+ {
+ return;
+ }
+
+ r->Halt = true;
+ Set(r->HaltEvent);
+ SetSockEvent(r->SockEvent);
+
+ if (r->ServerMode && r->NoNatTRegister == false)
+ {
+ WaitThread(r->IpQueryThread, INFINITE);
+ ReleaseThread(r->IpQueryThread);
+ }
+
+ WaitThread(r->Thread, INFINITE);
+ ReleaseThread(r->Thread);
+
+ for (i = 0;i < LIST_NUM(r->SessionList);i++)
+ {
+ RUDP_SESSION *se = LIST_DATA(r->SessionList, i);
+
+ RUDPFreeSession(se);
+ }
+
+ ReleaseList(r->SessionList);
+
+ for (i = 0;i < LIST_NUM(r->SendPacketList);i++)
+ {
+ UDPPACKET *p = LIST_DATA(r->SendPacketList, i);
+
+ FreeUdpPacket(p);
+ }
+
+ while (true)
+ {
+ SOCK *s = GetNext(r->NewSockQueue);
+ if (s == NULL)
+ {
+ break;
+ }
+
+ Disconnect(s);
+ ReleaseSock(s);
+ }
+
+ ReleaseQueue(r->NewSockQueue);
+
+ ReleaseList(r->SendPacketList);
+
+ FreeInterruptManager(r->Interrupt);
+
+ Disconnect(r->UdpSock);
+ ReleaseSock(r->UdpSock);
+ ReleaseSockEvent(r->SockEvent);
+ ReleaseEvent(r->HaltEvent);
+ ReleaseEvent(r->TargetConnectedEvent);
+
+ ReleaseEvent(r->NewSockConnectEvent);
+
+ Disconnect(r->TargetConnectedSock);
+ ReleaseSock(r->TargetConnectedSock);
+
+ DeleteLock(r->Lock);
+
+ if (r->RandPortId != 0)
+ {
+ rand_port_numbers[r->RandPortId] = 0;
+ }
+
+ Free(r);
+}
+
+// Generate a hash from the current computer name and the process name
+void GetCurrentMachineIpProcessHash(void *hash)
+{
+ // Validate arguments
+ if (hash == NULL)
+ {
+ return;
+ }
+
+ Lock(machine_ip_process_hash_lock);
+ {
+ if (IsZero(machine_ip_process_hash, SHA1_SIZE))
+ {
+ GetCurrentMachineIpProcessHashInternal(machine_ip_process_hash);
+ }
+
+ Copy(hash, machine_ip_process_hash, SHA1_SIZE);
+ }
+ Unlock(machine_ip_process_hash_lock);
+}
+void GetCurrentMachineIpProcessHashInternal(void *hash)
+{
+ BUF *b;
+ LIST *ip_list;
+ char machine_name[MAX_SIZE];
+ wchar_t exe_path[MAX_PATH];
+ char *product_id = NULL;
+ // Validate arguments
+ if (hash == NULL)
+ {
+ return;
+ }
+
+#ifdef OS_WIN32
+ product_id = MsRegReadStr(REG_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductId");
+ if (product_id == NULL)
+ {
+ product_id = MsRegReadStr(REG_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", "ProductId");
+ }
+#endif // OS_WIN32
+
+ b = NewBuf();
+
+ GetMachineHostName(machine_name, sizeof(machine_name));
+ Trim(machine_name);
+ StrUpper(machine_name);
+
+ GetExeNameW(exe_path, sizeof(exe_path));
+ UniTrim(exe_path);
+ UniStrUpper(exe_path);
+
+ WriteBuf(b, machine_name, StrSize(machine_name));
+ WriteBuf(b, exe_path, UniStrSize(exe_path));
+ WriteBuf(b, product_id, StrSize(product_id));
+
+ ip_list = GetHostIPAddressList();
+ if (ip_list != NULL)
+ {
+ UINT i;
+ for (i = 0;i < LIST_NUM(ip_list);i++)
+ {
+ IP *ip = LIST_DATA(ip_list, i);
+
+ WriteBuf(b, ip, sizeof(IP));
+ }
+ }
+ FreeHostIPAddressList(ip_list);
+
+ HashSha1(hash, b->Buf, b->Size);
+
+ FreeBuf(b);
+
+ Free(product_id);
+}
+
+// Create a pair of pre-bound TCP sockets
+bool NewTcpPair(SOCK **s1, SOCK **s2)
+{
+ SOCK *a;
+ SOCK *s, *c;
+ TUBE *t1, *t2;
+ SOCK_EVENT *e1, *e2;
+ // Validate arguments
+ if (s1 == NULL || s2 == NULL)
+ {
+ return false;
+ }
+
+ a = ListenAnyPortEx2(true, true);
+ if (a == NULL)
+ {
+ return false;
+ }
+
+ c = Connect("127.0.0.1", a->LocalPort);
+ if (c == NULL)
+ {
+ ReleaseSock(a);
+ return false;
+ }
+
+ s = Accept(a);
+ if (s == NULL)
+ {
+ ReleaseSock(c);
+ ReleaseSock(a);
+ return false;
+ }
+
+ ReleaseSock(a);
+
+ if ((s->LocalPort != c->RemotePort) || (s->RemotePort != c->LocalPort))
+ {
+ ReleaseSock(s);
+ ReleaseSock(c);
+ return false;
+ }
+
+ NewTubePair(&t1, &t2, sizeof(TCP_PAIR_HEADER));
+
+ // Creating a socket event
+ e1 = NewSockEvent();
+ e2 = NewSockEvent();
+
+ SetTubeSockEvent(t1, e1);
+ SetTubeSockEvent(t2, e2);
+
+ AddRef(t1->Ref);
+ AddRef(t2->Ref);
+ s->BulkRecvTube = c->BulkSendTube = t1;
+ s->BulkSendTube = c->BulkRecvTube = t2;
+
+ ReleaseSockEvent(e1);
+ ReleaseSockEvent(e2);
+
+ *s1 = s;
+ *s2 = c;
+
+ return true;
+}
+
+// Listen in any available port
+SOCK *ListenAnyPortEx(bool local_only)
+{
+ return ListenAnyPortEx2(local_only, false);
+}
+SOCK *ListenAnyPortEx2(bool local_only, bool disable_ca)
+{
+ UINT i;
+ SOCK *s;
+ for (i = 40000;i < 65536;i++)
+ {
+ s = ListenEx(i, local_only);
+ if (s != NULL)
+ {
+ return s;
+ }
+ }
+
+ return NULL;
+}
+
+int cb_test(int a, X509_STORE_CTX *ctx)
+{
+ WHERE;
+ return 1;
+}
+
+// Create a new SSL pipe
+SSL_PIPE *NewSslPipe(bool server_mode, X *x, K *k, DH_CTX *dh)
+{
+ SSL_PIPE *s;
+ SSL *ssl;
+ SSL_CTX *ssl_ctx = NewSSLCtx();
+
+ Lock(openssl_lock);
+ {
+ if (server_mode)
+ {
+ SSL_CTX_set_ssl_version(ssl_ctx, TLSv1_server_method());
+
+ AddChainSslCertOnDirectory(ssl_ctx);
+
+ if (dh != NULL)
+ {
+ SSL_CTX_set_tmp_dh(ssl_ctx, dh->dh);
+ }
+ }
+ else
+ {
+ SSL_CTX_set_ssl_version(ssl_ctx, TLSv1_client_method());
+ }
+
+ //SSL_CTX_set_verify(ssl_ctx, SSL_VERIFY_PEER, cb_test);
+
+ if (dh != NULL)
+ {
+ SSL_CTX_set_options(ssl_ctx, SSL_OP_SINGLE_DH_USE);
+ }
+
+ ssl = SSL_new(ssl_ctx);
+ }
+ Unlock(openssl_lock);
+
+ s = ZeroMalloc(sizeof(SSL_PIPE));
+
+ s->ssl = ssl;
+ s->ssl_ctx = ssl_ctx;
+ s->ServerMode = server_mode;
+
+ s->SslInOut = NewSslBioSsl();
+ s->RawIn = NewSslBioMem();
+ s->RawOut = NewSslBioMem();
+
+ if (x != NULL && k != NULL)
+ {
+ Lock(openssl_lock);
+ {
+ SSL_use_certificate(s->ssl, x->x509);
+ SSL_use_PrivateKey(s->ssl, k->pkey);
+ }
+ Unlock(openssl_lock);
+ }
+
+ if (s->ServerMode == false)
+ {
+ SSL_set_connect_state(s->ssl);
+ }
+ else
+ {
+ SSL_set_accept_state(s->ssl);
+ }
+
+ SSL_set_bio(s->ssl, s->RawIn->bio, s->RawOut->bio);
+ BIO_set_ssl(s->SslInOut->bio, s->ssl, BIO_NOCLOSE);
+
+ //s->RawIn->NoFree = true;
+ s->RawOut->NoFree = true;
+
+ return s;
+}
+
+// Synchronization of the SSL pipe
+bool SyncSslPipe(SSL_PIPE *s)
+{
+ UINT i;
+ // Validate arguments
+ if (s == NULL || s->IsDisconnected)
+ {
+ return false;
+ }
+
+ for (i = 0;i < 2;i++)
+ {
+ if (SslBioSync(s->RawIn, true, false) == false)
+ {
+ s->IsDisconnected = true;
+ Debug("SyncSslPipe: s->RawIn error.\n");
+ return false;
+ }
+
+ if (SslBioSync(s->RawOut, false, true) == false)
+ {
+ s->IsDisconnected = true;
+ Debug("SyncSslPipe: s->RawOut error.\n");
+ return false;
+ }
+
+ if (SslBioSync(s->SslInOut, true, true) == false)
+ {
+ s->IsDisconnected = true;
+ Debug("SyncSslPipe: s->SslInOut error.\n");
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Release of the SSL pipe
+void FreeSslPipe(SSL_PIPE *s)
+{
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+ FreeSslBio(s->SslInOut);
+ FreeSslBio(s->RawIn);
+ FreeSslBio(s->RawOut);
+
+ SSL_free(s->ssl);
+ SSL_CTX_free(s->ssl_ctx);
+
+ Free(s);
+}
+
+// Release of the SSL BIO
+void FreeSslBio(SSL_BIO *b)
+{
+ // Validate arguments
+ if (b == NULL)
+ {
+ return;
+ }
+
+ if (b->NoFree == false)
+ {
+ BIO_free(b->bio);
+ }
+
+ ReleaseFifo(b->RecvFifo);
+ ReleaseFifo(b->SendFifo);
+
+ Free(b);
+}
+
+// Create a new SSL BIO (SSL)
+SSL_BIO *NewSslBioSsl()
+{
+ SSL_BIO *b = ZeroMalloc(sizeof(SSL_BIO));
+
+ b->bio = BIO_new(BIO_f_ssl());
+
+ b->RecvFifo = NewFifo();
+ b->SendFifo = NewFifo();
+
+ return b;
+}
+
+// Create a new SSL BIO (memory)
+SSL_BIO *NewSslBioMem()
+{
+ SSL_BIO *b = ZeroMalloc(sizeof(SSL_BIO));
+
+ b->bio = BIO_new(BIO_s_mem());
+
+ b->RecvFifo = NewFifo();
+ b->SendFifo = NewFifo();
+
+ return b;
+}
+
+// Synchronize memory contents of the SSL BIO with the FIFO
+bool SslBioSync(SSL_BIO *b, bool sync_send, bool sync_recv)
+{
+ // Validate arguments
+ if (b == NULL)
+ {
+ return false;
+ }
+
+ if (b->IsDisconnected)
+ {
+ return false;
+ }
+
+ // Write the contents of the SendFifo to the BIO
+ if (sync_send)
+ {
+ while (b->SendFifo->size >= 1)
+ {
+ int r = BIO_write(b->bio, GetFifoPointer(b->SendFifo), FifoSize(b->SendFifo));
+
+ if (r == 0)
+ {
+ b->IsDisconnected = true;
+ WHERE;
+ return false;
+ }
+ else
+ {
+ if (r < 0)
+ {
+ if (BIO_should_retry(b->bio))
+ {
+ break;
+ }
+ else
+ {
+ b->IsDisconnected = true;
+ WHERE;
+ return false;
+ }
+ }
+ else
+ {
+ ReadFifo(b->SendFifo, NULL, (UINT)r);
+ }
+ }
+ }
+ }
+
+ // Save to the RecvFifo by reading from the BIO
+ if (sync_recv)
+ {
+ while (true)
+ {
+ UCHAR tmp[4096];
+ int r;
+
+ r = BIO_read(b->bio, tmp, sizeof(tmp));
+
+ if (r == 0)
+ {
+ b->IsDisconnected = true;
+ WHERE;
+ return false;
+ }
+ else
+ {
+ if (r < 0)
+ {
+ if (BIO_should_retry(b->bio))
+ {
+ break;
+ }
+ else
+ {
+ b->IsDisconnected = true;
+ WHERE;
+ Debug("OpenSSL Error: %s\n", ERR_error_string(ERR_peek_last_error(), NULL));
+ return false;
+ }
+ }
+ else
+ {
+ WriteFifo(b->RecvFifo, tmp, (UINT)r);
+ }
+ }
+ }
+ }
+
+ return true;
+}
+
+// Release the memory for the return value of the ICMP API
+void IcmpApiFreeResult(ICMP_RESULT *ret)
+{
+ // Validate arguments
+ if (ret == NULL)
+ {
+ return;
+ }
+
+ if (ret->Data != NULL)
+ {
+ Free(ret->Data);
+ }
+
+ Free(ret);
+}
+
+// Send an ICMP Echo using ICMP API
+ICMP_RESULT *IcmpApiEchoSend(IP *dest_ip, UCHAR ttl, UCHAR *data, UINT size, UINT timeout)
+{
+#ifdef OS_WIN32
+ // Validate arguments
+ if (dest_ip == NULL || IsIP4(dest_ip) == false || (size != 0 && data == NULL))
+ {
+ return NULL;
+ }
+ if (ttl == 0)
+ {
+ ttl = 127;
+ }
+
+ if (IsIcmpApiSupported())
+ {
+ HANDLE h;
+ DWORD dw;
+ IPAddr dest_addr;
+ UINT reply_size;
+ ICMP_ECHO_REPLY *reply;
+ ICMP_RESULT *ret = NULL;
+ IP_OPTION_INFORMATION opt;
+
+ h = w32net->IcmpCreateFile();
+
+ if (h == INVALID_HANDLE_VALUE)
+ {
+ return NULL;
+ }
+
+ Zero(&opt, sizeof(opt));
+ opt.Ttl = ttl;
+
+ IPToInAddr((struct in_addr *)&dest_addr, dest_ip);
+
+ reply_size = sizeof(*reply) + size + 64;
+ reply = ZeroMalloc(reply_size);
+
+ dw = w32net->IcmpSendEcho(h, dest_addr, data, size, &opt, reply, reply_size, timeout);
+
+ ret = ZeroMalloc(sizeof(ICMP_RESULT));
+
+ if (dw >= 1 && reply->Status == IP_SUCCESS)
+ {
+ ret->Ok = true;
+ }
+ else
+ {
+ switch (reply->Status)
+ {
+ case IP_DEST_NET_UNREACHABLE:
+ ret->Type = ICMP_TYPE_DESTINATION_UNREACHABLE;
+ ret->Code = ICMP_CODE_NET_UNREACHABLE;
+ break;
+
+ case IP_DEST_HOST_UNREACHABLE:
+ ret->Type = ICMP_TYPE_DESTINATION_UNREACHABLE;
+ ret->Code = ICMP_CODE_HOST_UNREACHABLE;
+ break;
+
+ case IP_DEST_PROT_UNREACHABLE:
+ ret->Type = ICMP_TYPE_DESTINATION_UNREACHABLE;
+ ret->Code = ICMP_CODE_PROTOCOL_UNREACHABLE;
+ break;
+
+ case IP_DEST_PORT_UNREACHABLE:
+ ret->Type = ICMP_TYPE_DESTINATION_UNREACHABLE;
+ ret->Code = ICMP_CODE_PORT_UNREACHABLE;
+ break;
+
+ case IP_TTL_EXPIRED_TRANSIT:
+ ret->Type = ICMP_TYPE_TIME_EXCEEDED;
+ ret->Code = ICMP_CODE_TTL_EXCEEDED_IN_TRANSIT;
+ break;
+
+ case IP_TTL_EXPIRED_REASSEM:
+ ret->Type = ICMP_TYPE_TIME_EXCEEDED;
+ ret->Code = ICMP_CODE_FRAGMENT_REASSEMBLY_TIME_EXCEEDED;
+ break;
+
+ default:
+ ret->Timeout = true;
+ break;
+ }
+ }
+
+ if (ret->Timeout == false)
+ {
+ ret->Ttl = reply->Options.Ttl;
+ ret->Rtt = reply->RoundTripTime;
+ InAddrToIP(&ret->IpAddress, (struct in_addr *)&reply->Address);
+
+ if (reply->DataSize >= 1 && reply->Data != NULL)
+ {
+ ret->DataSize = reply->DataSize;
+ ret->Data = Clone(reply->Data, reply->DataSize);
+ }
+ }
+
+ Free(reply);
+
+ w32net->IcmpCloseHandle(h);
+
+ return ret;
+ }
+ else
+ {
+ return NULL;
+ }
+
+#else // OS_WIN32
+ return NULL;
+#endif // OS_WIN32
+}
+
+// Detect whether the ICMP API is supported
+bool IsIcmpApiSupported()
+{
+#ifdef OS_WIN32
+ if (w32net->IcmpCloseHandle != NULL &&
+ w32net->IcmpCreateFile != NULL &&
+ w32net->IcmpSendEcho != NULL)
+ {
+ return true;
+ }
+#endif // OS_WIN32
+
+ return false;
+}
+
+// Initialize the routing table change detector
+ROUTE_CHANGE *NewRouteChange()
+{
+#ifdef OS_WIN32
+ return Win32NewRouteChange();
+#else // OS_WIN32
+ return NULL;
+#endif // OS_WIN32
+}
+
+// Release the routing table change detector
+void FreeRouteChange(ROUTE_CHANGE *r)
+{
+#ifdef OS_WIN32
+ Win32FreeRouteChange(r);
+#endif // OS_WIN32
+}
+
+// Get whether the routing table has been changed
+bool IsRouteChanged(ROUTE_CHANGE *r)
+{
+#ifdef OS_WIN32
+ return Win32IsRouteChanged(r);
+#else // OS_WIN32
+ return false;
+#endif // OS_WIN32
+}
+
+// Routing table change detector function (Win32)
+#ifdef OS_WIN32
+ROUTE_CHANGE *Win32NewRouteChange()
+{
+ ROUTE_CHANGE *r;
+ bool ret;
+
+ if (MsIsNt() == false)
+ {
+ return NULL;
+ }
+
+ if (w32net->CancelIPChangeNotify == NULL ||
+ w32net->NotifyRouteChange == NULL)
+ {
+ return NULL;
+ }
+
+ r = ZeroMalloc(sizeof(ROUTE_CHANGE));
+
+ r->Data = ZeroMalloc(sizeof(ROUTE_CHANGE_DATA));
+
+ r->Data->Overlapped.hEvent = CreateEventA(NULL, false, true, NULL);
+
+ ret = w32net->NotifyRouteChange(&r->Data->Handle, &r->Data->Overlapped);
+ if (!(ret == NO_ERROR || ret == WSA_IO_PENDING || WSAGetLastError() == WSA_IO_PENDING))
+ {
+ Free(r->Data);
+ Free(r);
+
+ return NULL;
+ }
+
+ return r;
+}
+
+void Win32FreeRouteChange(ROUTE_CHANGE *r)
+{
+ // Validate arguments
+ if (r == NULL)
+ {
+ return;
+ }
+
+ w32net->CancelIPChangeNotify(&r->Data->Overlapped);
+ CloseHandle(r->Data->Overlapped.hEvent);
+
+ Free(r->Data);
+ Free(r);
+}
+
+bool Win32IsRouteChanged(ROUTE_CHANGE *r)
+{
+ // Validate arguments
+ if (r == NULL)
+ {
+ return false;
+ }
+
+ if ((r->Data->NumCalled++) == 0)
+ {
+ return true;
+ }
+
+ if (WaitForSingleObject(r->Data->Overlapped.hEvent, 0) == WAIT_OBJECT_0)
+ {
+ w32net->NotifyRouteChange(&r->Data->Handle, &r->Data->Overlapped);
+ return true;
+ }
+
+ return false;
+}
+
+typedef struct WIN32_ACCEPT_CHECK_DATA
+{
+ bool IsIPv6;
+ bool Rejected;
+} WIN32_ACCEPT_CHECK_DATA;
+
+// Function for determining whether accept or not in Win32
+int CALLBACK Win32AcceptCheckCallback_Delay(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
+ LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
+ GROUP FAR * g, DWORD_PTR dwCallbackData)
+{
+ return CF_DEFER;
+}
+
+int CALLBACK Win32AcceptCheckCallback(LPWSABUF lpCallerId, LPWSABUF lpCallerData, LPQOS pQos,
+ LPQOS lpGQOS, LPWSABUF lpCalleeId, LPWSABUF lpCalleeData,
+ GROUP FAR * g, DWORD_PTR dwCallbackData)
+{
+ return CF_ACCEPT;
+}
+
+// Accept function for Win32
+SOCKET Win32Accept_XP(SOCK *sock, SOCKET s, struct sockaddr *addr, int *addrlen, bool ipv6)
+{
+ SOCKET ret;
+ WIN32_ACCEPT_CHECK_DATA d;
+ UINT err;
+ int initial_addrlen = *addrlen;
+ UINT num_error = 0;
+ // Validate arguments
+ if (s == INVALID_SOCKET)
+ {
+ return INVALID_SOCKET;
+ }
+
+L_LOOP:
+
+ Zero(&d, sizeof(d));
+
+ d.IsIPv6 = ipv6;
+
+ *addrlen = initial_addrlen;
+ Zero(addr, initial_addrlen);
+ ret = WSAAccept(s, addr, addrlen, Win32AcceptCheckCallback, (DWORD_PTR)&d);
+
+ if (ret == INVALID_SOCKET)
+ {
+ err = WSAGetLastError();
+
+ num_error++;
+
+ Debug("!!! WSAAccept Error: %u rej=%u num=%u tick=%I64u\n", WSAGetLastError(), d.Rejected, num_error, Tick64());
+
+ if (d.Rejected && err == WSAECONNREFUSED)
+ {
+ goto L_LOOP;
+ }
+
+ if (err == WSAETIMEDOUT)
+ {
+ goto L_LOOP;
+ }
+ }
+
+ return ret;
+}
+
+// Accept function for Win32
+SOCKET Win32Accept(SOCK *sock, SOCKET s, struct sockaddr *addr, int *addrlen, bool ipv6)
+{
+ SOCKET ret;
+ WIN32_ACCEPT_CHECK_DATA d;
+ UINT err;
+ int initial_addrlen = *addrlen;
+ UINT num_error = 0;
+ UINT zero = 0;
+ UINT tmp = 0;
+ UINT ret_size = 0;
+ // Validate arguments
+ if (sock == NULL || s == INVALID_SOCKET)
+ {
+ return INVALID_SOCKET;
+ }
+
+ if (sock->hAcceptEvent == NULL)
+ {
+ sock->hAcceptEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+
+ WSAEventSelect(s, sock->hAcceptEvent, FD_ACCEPT | FD_CLOSE);
+ }
+
+L_LOOP:
+
+ if (sock->CancelAccept)
+ {
+ return INVALID_SOCKET;
+ }
+
+ Zero(&d, sizeof(d));
+
+ d.IsIPv6 = ipv6;
+
+ *addrlen = initial_addrlen;
+ Zero(addr, initial_addrlen);
+ ret = WSAAccept(s, addr, addrlen, Win32AcceptCheckCallback, (DWORD_PTR)&d);
+
+ if (ret == INVALID_SOCKET)
+ {
+ err = WSAGetLastError();
+
+ if (err == WSAEWOULDBLOCK)
+ {
+ //Debug("!!! WSAAccept: WSAEWOULDBLOCK\n");
+ UINT wait_ret = WaitForSingleObject(sock->hAcceptEvent, 1234);
+
+ if (wait_ret == WAIT_OBJECT_0 || wait_ret == WAIT_TIMEOUT)
+ {
+ goto L_LOOP;
+ }
+
+ Debug("!!! WaitForSingleObject Error. ret=%u GetLastError=%u\n", wait_ret, GetLastError());
+ }
+
+ num_error++;
+
+ Debug("!!! WSAAccept Error: %u rej=%u num=%u tick=%I64u\n", err, d.Rejected, num_error, Tick64());
+
+ if (d.Rejected && err == WSAECONNREFUSED)
+ {
+ goto L_LOOP;
+ }
+
+ if (err == WSAETIMEDOUT)
+ {
+ goto L_LOOP;
+ }
+ }
+ else
+ {
+ // Remove a new socket from the event
+ WSAEventSelect(ret, sock->hAcceptEvent, 0);
+
+ // Restore the new socket to synchronized
+ WSAIoctl(ret, FIONBIO, &zero, sizeof(zero), &tmp, sizeof(tmp), &ret_size, NULL, NULL);
+ }
+
+ return ret;
+}
+
+#endif // OS_WIN32
+
+
+// Get whether the aquirement of the Process ID of the TCP connection succeed
+bool CanGetTcpProcessId()
+{
+ UINT i;
+ bool ret = false;
+ LIST *o = GetTcpTableList();
+
+ if (o == NULL)
+ {
+ return false;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ TCPTABLE *t = LIST_DATA(o, i);
+
+ if (t->ProcessId != 0)
+ {
+ ret = true;
+ break;
+ }
+ }
+
+ FreeTcpTableList(o);
+
+ return ret;
+}
+
+
+
+
+#define USE_OLD_GETIP
+
+// Set the arp_filter in Linux
+void SetLinuxArpFilter()
+{
+ char *filename = "/proc/sys/net/ipv4/conf/all/arp_filter";
+ char *data = "1\n";
+ IO *o;
+
+ o = FileCreate(filename);
+ if (o == NULL)
+ {
+ return;
+ }
+
+ FileWrite(o, data, StrLen(data));
+ FileFlush(o);
+
+ FileClose(o);
+}
+
+// Determine whether the string is a IPv6 mask
+bool IsIpMask6(char *str)
+{
+ IP mask;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return false;
+ }
+
+ return StrToMask6(&mask, str);
+}
+
+// Determine whether the string is a IPv6 address
+bool IsStrIPv6Address(char *str)
+{
+ IP ip;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return false;
+ }
+
+ if (StrToIP6(&ip, str) == false)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Convert the subnet mask to an integer
+UINT SubnetMaskToInt6(IP *a)
+{
+ UINT i;
+ // Validate arguments
+ if (IsIP6(a) == false)
+ {
+ return 0;
+ }
+
+ for (i = 0;i <= 128;i++)
+ {
+ IP tmp;
+
+ IntToSubnetMask6(&tmp, i);
+
+ if (CmpIpAddr(a, &tmp) == 0)
+ {
+ return i;
+ }
+ }
+
+ return 0;
+}
+UINT SubnetMaskToInt4(IP *a)
+{
+ UINT i;
+ // Validate arguments
+ if (IsIP4(a) == false)
+ {
+ return 0;
+ }
+
+ for (i = 0;i <= 32;i++)
+ {
+ IP tmp;
+
+ IntToSubnetMask4(&tmp, i);
+
+ if (CmpIpAddr(a, &tmp) == 0)
+ {
+ return i;
+ }
+ }
+
+ return 0;
+}
+UINT SubnetMaskToInt(IP *a)
+{
+ if (IsIP6(a))
+ {
+ return SubnetMaskToInt6(a);
+ }
+ else
+ {
+ return SubnetMaskToInt4(a);
+ }
+}
+
+// Determine whether the specified IP address is a subnet mask
+bool IsSubnetMask6(IP *a)
+{
+ UINT i;
+ // Validate arguments
+ if (IsIP6(a) == false)
+ {
+ return false;
+ }
+
+ for (i = 0;i <= 128;i++)
+ {
+ IP tmp;
+
+ IntToSubnetMask6(&tmp, i);
+
+ if (CmpIpAddr(a, &tmp) == 0)
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// Generate a global address from the MAC address
+void GenerateEui64GlobalAddress(IP *ip, IP *prefix, IP *subnet, UCHAR *mac)
+{
+ UCHAR tmp[8];
+ IP a;
+ IP subnet_not;
+ IP or1, or2;
+ // Validate arguments
+ if (ip == NULL || prefix == NULL || subnet == NULL || mac == NULL)
+ {
+ return;
+ }
+
+ GenerateEui64Address6(tmp, mac);
+
+ ZeroIP6(&a);
+
+ Copy(&a.ipv6_addr[8], tmp, 8);
+
+ IPNot6(&subnet_not, subnet);
+ IPAnd6(&or1, &a, &subnet_not);
+ IPAnd6(&or2, prefix, subnet);
+
+ IPOr6(ip, &or1, &or2);
+}
+
+// Generate a local address from the MAC address
+void GenerateEui64LocalAddress(IP *a, UCHAR *mac)
+{
+ UCHAR tmp[8];
+ // Validate arguments
+ if (a == NULL || mac == NULL)
+ {
+ return;
+ }
+
+ GenerateEui64Address6(tmp, mac);
+
+ ZeroIP6(a);
+ a->ipv6_addr[0] = 0xfe;
+ a->ipv6_addr[1] = 0x80;
+
+ Copy(&a->ipv6_addr[8], tmp, 8);
+}
+
+// Generate the EUI-64 address from the MAC address
+void GenerateEui64Address6(UCHAR *dst, UCHAR *mac)
+{
+ // Validate arguments
+ if (dst == NULL || mac == NULL)
+ {
+ return;
+ }
+
+ Copy(dst, mac, 3);
+ Copy(dst + 5, mac, 3);
+
+ dst[3] = 0xff;
+ dst[4] = 0xfe;
+ dst[0] = ((~(dst[0] & 0x02)) & 0x02) | (dst[0] & 0xfd);
+}
+
+// Examine whether two IP addresses are in the same network
+bool IsInSameNetwork6ByStr(char *ip1, char *ip2, char *subnet)
+{
+ IP p1, p2, s;
+
+ if (StrToIP6(&p1, ip1) == false)
+ {
+ return false;
+ }
+
+ if (StrToIP6(&p2, ip2) == false)
+ {
+ return false;
+ }
+
+ if (StrToMask6(&s, subnet) == false)
+ {
+ return false;
+ }
+
+ return IsInSameNetwork6(&p1, &p2, &s);
+}
+bool IsInSameNetwork6(IP *a1, IP *a2, IP *subnet)
+{
+ IP prefix1, prefix2;
+ // Validate arguments
+ if (IsIP6(a1) == false || IsIP6(a2) == false || IsIP6(subnet) == false)
+ {
+ return false;
+ }
+
+ if (a1->ipv6_scope_id != a2->ipv6_scope_id)
+ {
+ return false;
+ }
+
+ GetPrefixAddress6(&prefix1, a1, subnet);
+ GetPrefixAddress6(&prefix2, a2, subnet);
+
+ if (CmpIpAddr(&prefix1, &prefix2) == 0)
+ {
+ return true;
+ }
+
+ return false;
+}
+bool IsInSameNetwork4(IP *a1, IP *a2, IP *subnet)
+{
+ IP net1, net2;
+ // Validate arguments
+ if (IsIP4(a1) == false || IsIP4(a2) == false || IsIP4(subnet) == false)
+ {
+ return false;
+ }
+
+ IPAnd4(&net1, a1, subnet);
+ IPAnd4(&net2, a2, subnet);
+
+ if (CmpIpAddr(&net1, &net2) == 0)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+// Check whether it is a network address prefix
+bool IsNetworkAddress6(IP *ip, IP *subnet)
+{
+ return IsNetworkPrefixAddress6(ip, subnet);
+}
+bool IsNetworkPrefixAddress6(IP *ip, IP *subnet)
+{
+ IP host;
+ // Validate arguments
+ if (ip == NULL || subnet == NULL)
+ {
+ return false;
+ }
+
+ if (IsIP6(ip) == false || IsIP6(subnet) == false)
+ {
+ return false;
+ }
+
+ GetHostAddress6(&host, ip, subnet);
+
+ if (IsZeroIp(&host))
+ {
+ return true;
+ }
+
+ return false;
+}
+
+// Check whether the unicast address is available
+bool CheckUnicastAddress(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if ((GetIPAddrType6(ip) & IPV6_ADDR_UNICAST) == 0)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Get the host address
+void GetHostAddress6(IP *dst, IP *ip, IP *subnet)
+{
+ IP not;
+ // Validate arguments
+ if (dst == NULL || ip == NULL || subnet == NULL)
+ {
+ return;
+ }
+
+ IPNot6(¬, subnet);
+
+ IPAnd6(dst, ip, ¬);
+
+ dst->ipv6_scope_id = ip->ipv6_scope_id;
+}
+
+// Get the prefix address
+void GetPrefixAddress6(IP *dst, IP *ip, IP *subnet)
+{
+ // Validate arguments
+ if (dst == NULL || ip == NULL || subnet == NULL)
+ {
+ return;
+ }
+
+ IPAnd6(dst, ip, subnet);
+
+ dst->ipv6_scope_id = ip->ipv6_scope_id;
+}
+
+// Get the solicited-node multicast address
+void GetSoliciationMulticastAddr6(IP *dst, IP *src)
+{
+ IP prefix;
+ IP mask104;
+ IP or1, or2;
+
+ // Validate arguments
+ if (dst == NULL || src == NULL)
+ {
+ return;
+ }
+
+ ZeroIP6(&prefix);
+ prefix.ipv6_addr[0] = 0xff;
+ prefix.ipv6_addr[1] = 0x02;
+ prefix.ipv6_addr[11] = 0x01;
+ prefix.ipv6_addr[12] = 0xff;
+
+ IntToSubnetMask6(&mask104, 104);
+
+ IPAnd6(&or1, &prefix, &mask104);
+ IPAnd6(&or2, src, &mask104);
+
+ IPOr6(dst, &or1, &or2);
+
+ dst->ipv6_scope_id = src->ipv6_scope_id;
+}
+
+// Generate a MAC address corresponding to the multicast address
+void GenerateMulticastMacAddress6(UCHAR *mac, IP *ip)
+{
+ // Validate arguments
+ if (mac == NULL)
+ {
+ return;
+ }
+
+ mac[0] = 0x33;
+ mac[1] = 0x33;
+ mac[2] = ip->ipv6_addr[12];
+ mac[3] = ip->ipv6_addr[13];
+ mac[4] = ip->ipv6_addr[14];
+ mac[5] = ip->ipv6_addr[15];
+}
+
+// Get the type of the IPv6 address
+UINT GetIPv6AddrType(IPV6_ADDR *addr)
+{
+ IP ip;
+ // Validate arguments
+ if (addr == NULL)
+ {
+ return 0;
+ }
+
+ IPv6AddrToIP(&ip, addr);
+
+ return GetIPAddrType6(&ip);
+}
+UINT GetIPAddrType6(IP *ip)
+{
+ UINT ret = 0;
+ // Validate arguments
+ if (IsIP6(ip) == false)
+ {
+ return 0;
+ }
+
+ if (ip->ipv6_addr[0] == 0xff)
+ {
+ IP all_node, all_router;
+
+ GetAllNodeMulticaseAddress6(&all_node);
+
+ GetAllRouterMulticastAddress6(&all_router);
+
+ ret |= IPV6_ADDR_MULTICAST;
+
+ if (Cmp(ip->ipv6_addr, all_node.ipv6_addr, 16) == 0)
+ {
+ ret |= IPV6_ADDR_ALL_NODE_MULTICAST;
+ }
+ else if (Cmp(ip->ipv6_addr, all_router.ipv6_addr, 16) == 0)
+ {
+ ret |= IPV6_ADDR_ALL_ROUTER_MULTICAST;
+ }
+ 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)
+ {
+ ret |= IPV6_ADDR_SOLICIATION_MULTICAST;
+ }
+ }
+ }
+ else
+ {
+ ret |= IPV6_ADDR_UNICAST;
+
+ if (ip->ipv6_addr[0] == 0xfe && (ip->ipv6_addr[1] & 0xc0) == 0x80)
+ {
+ ret |= IPV6_ADDR_LOCAL_UNICAST;
+ }
+ else
+ {
+ ret |= IPV6_ADDR_GLOBAL_UNICAST;
+
+ if (IsZero(&ip->ipv6_addr, 16))
+ {
+ ret |= IPV6_ADDR_ZERO;
+ }
+ else
+ {
+ IP loopback;
+
+ GetLoopbackAddress6(&loopback);
+
+ if (Cmp(ip->ipv6_addr, loopback.ipv6_addr, 16) == 0)
+ {
+ ret |= IPV6_ADDR_LOOPBACK;
+ }
+ }
+ }
+ }
+
+ return ret;
+}
+
+// Address that all of the bits are set
+void GetAllFilledAddress6(IP *ip)
+{
+ UINT i;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ ZeroIP6(ip);
+
+ for (i = 0;i < 15;i++)
+ {
+ ip->ipv6_addr[i] = 0xff;
+ }
+}
+
+// Loopback address
+void GetLoopbackAddress6(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ ZeroIP6(ip);
+
+ ip->ipv6_addr[15] = 0x01;
+}
+
+// All-nodes multicast address
+void GetAllNodeMulticaseAddress6(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ ZeroIP6(ip);
+
+ ip->ipv6_addr[0] = 0xff;
+ ip->ipv6_addr[1] = 0x02;
+ ip->ipv6_addr[15] = 0x01;
+}
+
+// All-routers multicast address
+void GetAllRouterMulticastAddress6(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ ZeroIP6(ip);
+
+ ip->ipv6_addr[0] = 0xff;
+ ip->ipv6_addr[1] = 0x02;
+ ip->ipv6_addr[15] = 0x02;
+}
+
+// Logical operation of the IPv4 address
+void IPNot4(IP *dst, IP *a)
+{
+ UINT i;
+ // Validate arguments
+ if (dst == NULL || a == NULL || IsIP4(a) == false)
+ {
+ Zero(dst, sizeof(IP));
+ return;
+ }
+
+ i = IPToUINT(a);
+ i = ~i;
+
+ UINTToIP(dst, i);
+}
+void IPOr4(IP *dst, IP *a, IP *b)
+{
+ UINT i;
+ // Validate arguments
+ if (dst == NULL || a == NULL || b == NULL || IsIP4(a) == false || IsIP4(b) == false)
+ {
+ Zero(dst, sizeof(IP));
+ return;
+ }
+
+ i = IPToUINT(a) | IPToUINT(b);
+
+ UINTToIP(dst, i);
+}
+void IPAnd4(IP *dst, IP *a, IP *b)
+{
+ UINT i;
+ // Validate arguments
+ if (dst == NULL || a == NULL || b == NULL || IsIP4(a) == false || IsIP4(b) == false)
+ {
+ Zero(dst, sizeof(IP));
+ return;
+ }
+
+ i = IPToUINT(a) & IPToUINT(b);
+
+ UINTToIP(dst, i);
+}
+
+// Logical operation of the IPv6 address
+void IPAnd6(IP *dst, IP *a, IP *b)
+{
+ UINT i;
+ // Validate arguments
+ if (dst == NULL || IsIP6(a) == false || IsIP6(b) == false)
+ {
+ ZeroIP6(dst);
+ return;
+ }
+
+ ZeroIP6(dst);
+ for (i = 0;i < 16;i++)
+ {
+ dst->ipv6_addr[i] = a->ipv6_addr[i] & b->ipv6_addr[i];
+ }
+}
+void IPOr6(IP *dst, IP *a, IP *b)
+{
+ UINT i;
+ // Validate arguments
+ if (dst == NULL || IsIP6(a) == false || IsIP6(b) == false)
+ {
+ ZeroIP6(dst);
+ return;
+ }
+
+ ZeroIP6(dst);
+ for (i = 0;i < 16;i++)
+ {
+ dst->ipv6_addr[i] = a->ipv6_addr[i] | b->ipv6_addr[i];
+ }
+}
+void IPNot6(IP *dst, IP *a)
+{
+ UINT i;
+ // Validate arguments
+ if (dst == NULL || IsIP6(a) == false)
+ {
+ ZeroIP6(dst);
+ return;
+ }
+
+ ZeroIP6(dst);
+ for (i = 0;i < 16;i++)
+ {
+ dst->ipv6_addr[i] = ~(a->ipv6_addr[i]);
+ }
+}
+
+// Creating a subnet mask
+void IntToSubnetMask6(IP *ip, UINT i)
+{
+ UINT j = i / 8;
+ UINT k = i % 8;
+ UINT z;
+ IP a;
+
+ ZeroIP6(&a);
+
+ for (z = 0;z < 16;z++)
+ {
+ if (z < j)
+ {
+ a.ipv6_addr[z] = 0xff;
+ }
+ else if (z == j)
+ {
+ a.ipv6_addr[z] = ~(0xff >> k);
+ }
+ }
+
+ Copy(ip, &a, sizeof(IP));
+}
+
+// Convert the IP address to a string
+void IP6AddrToStr(char *str, UINT size, IPV6_ADDR *addr)
+{
+ // Validate arguments
+ if (str == NULL || addr == NULL)
+ {
+ return;
+ }
+
+ IPToStr6Array(str, size, addr->Value);
+}
+void IPToStr6Array(char *str, UINT size, UCHAR *bytes)
+{
+ IP ip;
+ // Validate arguments
+ if (str == NULL || bytes == NULL)
+ {
+ return;
+ }
+
+ SetIP6(&ip, bytes);
+
+ IPToStr6(str, size, &ip);
+}
+void IPToStr6(char *str, UINT size, IP *ip)
+{
+ char tmp[MAX_SIZE];
+
+ IPToStr6Inner(tmp, ip);
+
+ StrCpy(str, size, tmp);
+}
+void IPToStr6Inner(char *str, IP *ip)
+{
+ UINT i;
+ USHORT values[8];
+ UINT zero_started_index;
+ UINT max_zero_len;
+ UINT max_zero_start;
+ IP a;
+ // Validate arguments
+ if (str == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ Copy(&a, ip, sizeof(IP));
+
+ for (i = 0;i < 8;i++)
+ {
+ Copy(&values[i], &a.ipv6_addr[i * 2], sizeof(USHORT));
+ values[i] = Endian16(values[i]);
+ }
+
+ // Search for omitable part
+ zero_started_index = INFINITE;
+ max_zero_len = 0;
+ max_zero_start = INFINITE;
+ for (i = 0;i < 9;i++)
+ {
+ USHORT v = (i != 8 ? values[i] : 1);
+
+ if (v == 0)
+ {
+ if (zero_started_index == INFINITE)
+ {
+ zero_started_index = i;
+ }
+ }
+ else
+ {
+ UINT zero_len;
+
+ if (zero_started_index != INFINITE)
+ {
+ zero_len = i - zero_started_index;
+ if (zero_len >= 2)
+ {
+ if (max_zero_len < zero_len)
+ {
+ max_zero_start = zero_started_index;
+ max_zero_len = zero_len;
+ }
+ }
+
+ zero_started_index = INFINITE;
+ }
+ }
+ }
+
+ // Format a string
+ StrCpy(str, 0, "");
+ for (i = 0;i < 8;i++)
+ {
+ char tmp[16];
+
+ ToHex(tmp, values[i]);
+ StrLower(tmp);
+
+ if (i == max_zero_start)
+ {
+ if (i == 0)
+ {
+ StrCat(str, 0, "::");
+ }
+ else
+ {
+ StrCat(str, 0, ":");
+ }
+ i += max_zero_len - 1;
+ }
+ else
+ {
+ StrCat(str, 0, tmp);
+ if (i != 7)
+ {
+ StrCat(str, 0, ":");
+ }
+ }
+ }
+
+ // Scope ID
+ if (ip->ipv6_scope_id != 0)
+ {
+ char tmp[64];
+
+ StrCat(str, 0, "%");
+ ToStr(tmp, ip->ipv6_scope_id);
+
+ StrCat(str, 0, tmp);
+ }
+}
+
+// Convert the string to an IP address
+bool StrToIP6(IP *ip, char *str)
+{
+ TOKEN_LIST *t;
+ char tmp[MAX_PATH];
+ IP a;
+ UINT i;
+ UINT scope_id = 0;
+ // Validate arguments
+ if (str == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ ZeroIP6(&a);
+
+ StrCpy(tmp, sizeof(tmp), str);
+ Trim(tmp);
+
+ if (StartWith(tmp, "[") && EndWith(tmp, "]"))
+ {
+ // If the string is enclosed in square brackets, remove brackets
+ StrCpy(tmp, sizeof(tmp), &tmp[1]);
+
+ if (StrLen(tmp) >= 1)
+ {
+ tmp[StrLen(tmp) - 1] = 0;
+ }
+ }
+
+ // Remove the scope ID by analyzing if there is it
+ i = SearchStrEx(tmp, "%", 0, false);
+ if (i != INFINITE)
+ {
+ char ss[MAX_PATH];
+
+ StrCpy(ss, sizeof(ss), &tmp[i + 1]);
+
+ tmp[i] = 0;
+
+ Trim(tmp);
+
+ Trim(ss);
+
+ scope_id = ToInt(ss);
+ }
+
+ // Tokenize
+ t = ParseTokenWithNullStr(tmp, ":");
+ if (t->NumTokens >= 3 && t->NumTokens <= 8)
+ {
+ UINT i, n;
+ bool b = true;
+ UINT k = 0;
+
+ n = 0;
+
+ for (i = 0;i < t->NumTokens;i++)
+ {
+ char *str = t->Token[i];
+
+ if (i != 0 && i != (t->NumTokens - 1) && StrLen(str) == 0)
+ {
+ n++;
+ if (n == 1)
+ {
+ k += 2 * (8 - t->NumTokens + 1);
+ }
+ else
+ {
+ b = false;
+ break;
+ }
+ }
+ else
+ {
+ UCHAR chars[2];
+
+ if (CheckIPItemStr6(str) == false)
+ {
+ b = false;
+ break;
+ }
+
+ IPItemStrToChars6(chars, str);
+
+ a.ipv6_addr[k++] = chars[0];
+ a.ipv6_addr[k++] = chars[1];
+ }
+ }
+
+ if (n != 0 && n != 1)
+ {
+ b = false;
+ }
+ else if (n == 0 && t->NumTokens != 8)
+ {
+ b = false;
+ }
+
+ if (b == false)
+ {
+ FreeToken(t);
+ return false;
+ }
+ }
+ else
+ {
+ FreeToken(t);
+ return false;
+ }
+
+ FreeToken(t);
+
+ Copy(ip, &a, sizeof(IP));
+
+ ip->ipv6_scope_id = scope_id;
+
+ return true;
+}
+bool StrToIP6Addr(IPV6_ADDR *ip, char *str)
+{
+ IP ip2;
+ // Validate arguments
+ if (ip == NULL || str == NULL)
+ {
+ Zero(ip, sizeof(IPV6_ADDR));
+ return false;
+ }
+
+ if (StrToIP6(&ip2, str) == false)
+ {
+ return false;
+ }
+
+ if (IPToIPv6Addr(ip, &ip2) == false)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Convert an IP address character to the UCHAR type
+void IPItemStrToChars6(UCHAR *chars, char *str)
+{
+ char tmp[5];
+ BUF *b;
+ UINT len;
+ // Validate arguments
+ if (chars == NULL)
+ {
+ return;
+ }
+
+ Zero(tmp, sizeof(tmp));
+
+ len = StrLen(str);
+ switch (len)
+ {
+ case 0:
+ tmp[0] = tmp[1] = tmp[2] = tmp[3] = '0';
+ break;
+
+ case 1:
+ tmp[0] = tmp[1] = tmp[2] = '0';
+ tmp[3] = str[0];
+ break;
+
+ case 2:
+ tmp[0] = tmp[1] = '0';
+ tmp[2] = str[0];
+ tmp[3] = str[1];
+ break;
+
+ case 3:
+ tmp[0] = '0';
+ tmp[1] = str[0];
+ tmp[2] = str[1];
+ tmp[3] = str[2];
+ break;
+
+ case 4:
+ tmp[0] = str[0];
+ tmp[1] = str[1];
+ tmp[2] = str[2];
+ tmp[3] = str[3];
+ break;
+ }
+
+ b = StrToBin(tmp);
+
+ chars[0] = ((UCHAR *)b->Buf)[0];
+ chars[1] = ((UCHAR *)b->Buf)[1];
+
+ FreeBuf(b);
+}
+
+// Check whether invalid characters are included in the element string of the IP address
+bool CheckIPItemStr6(char *str)
+{
+ UINT i, len;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return false;
+ }
+
+ len = StrLen(str);
+ if (len >= 5)
+ {
+ // Invalid length
+ return false;
+ }
+
+ for (i = 0;i < len;i++)
+ {
+ char c = str[i];
+
+ if ((c >= 'a' && c <= 'f') ||
+ (c >= 'A' && c <= 'F') ||
+ (c >= '0' && c <= '9'))
+ {
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ return true;
+}
+
+// Create an IPv4 address of all zero
+void ZeroIP4(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ Zero(ip, sizeof(IP));
+}
+
+// Create an IPv6 address of all zero
+void ZeroIP6(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ SetIP6(ip, NULL);
+}
+
+// Get the IP address of the localhost
+void GetLocalHostIP6(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+ ZeroIP6(ip);
+
+ ip->ipv6_addr[15] = 1;
+}
+void GetLocalHostIP4(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ SetIP(ip, 127, 0, 0, 1);
+}
+
+// Check whether the specified address is a localhost
+bool IsLocalHostIP6(IP *ip)
+{
+ IP local;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+ if (IsIP6(ip) == false)
+ {
+ return false;
+ }
+
+ GetLocalHostIP6(&local);
+
+ if (CmpIpAddr(&local, ip) == 0)
+ {
+ return true;
+ }
+
+ return false;
+}
+bool IsLocalHostIP4(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+ if (IsIP4(ip) == false)
+ {
+ return false;
+ }
+
+ if (ip->addr[0] == 127)
+ {
+ return true;
+ }
+
+ return false;
+}
+bool IsLocalHostIP(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if (IsIP4(ip))
+ {
+ return IsLocalHostIP4(ip);
+ }
+ else
+ {
+ return IsLocalHostIP6(ip);
+ }
+}
+
+// Convert the IPV6_ADDR to an IP
+void IPv6AddrToIP(IP *ip, IPV6_ADDR *addr)
+{
+ // Validate arguments
+ if (ip == NULL || addr == NULL)
+ {
+ return;
+ }
+
+ SetIP6(ip, addr->Value);
+}
+
+// Convert the IP to an IPV6_ADDR
+bool IPToIPv6Addr(IPV6_ADDR *addr, IP *ip)
+{
+ UINT i;
+ // Validate arguments
+ if (addr == NULL || ip == NULL)
+ {
+ Zero(addr, sizeof(IPV6_ADDR));
+ return false;
+ }
+
+ if (IsIP6(ip) == false)
+ {
+ Zero(addr, sizeof(IPV6_ADDR));
+ return false;
+ }
+
+ for (i = 0;i < 16;i++)
+ {
+ addr->Value[i] = ip->ipv6_addr[i];
+ }
+
+ return true;
+}
+
+// Set an IPv6 address
+void SetIP6(IP *ip, UCHAR *value)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ Zero(ip, sizeof(IP));
+
+ ip->addr[0] = 223;
+ ip->addr[1] = 255;
+ ip->addr[2] = 255;
+ ip->addr[3] = 254;
+
+ if (value != NULL)
+ {
+ UINT i;
+
+ for (i = 0;i < 16;i++)
+ {
+ ip->ipv6_addr[i] = value[i];
+ }
+ }
+}
+
+// Check whether the specified address is a IPv6 address
+bool IsIP6(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if (ip->addr[0] == 223 && ip->addr[1] == 255 && ip->addr[2] == 255 && ip->addr[3] == 254)
+ {
+ return true;
+ }
+
+ return false;
+}
+bool IsIP4(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ return (IsIP6(ip) ? false : true);
+}
+
+// Examine whether the version of the two IP addresses are same
+bool IsSameIPVer(IP *ip1, IP *ip2)
+{
+ // Validate arguments
+ if (ip1 == NULL || ip2 == NULL)
+ {
+ return false;
+ }
+
+ if (IsIP4(ip1) && IsIP4(ip2))
+ {
+ return true;
+ }
+
+ if (IsIP6(ip1) && IsIP6(ip2))
+ {
+ return true;
+ }
+
+ return false;
+}
+
+// Copy the IP address
+void CopyIP(IP *dst, IP *src)
+{
+ Copy(dst, src, sizeof(IP));
+}
+
+// Check the length of the IPv6 subnet
+bool CheckSubnetLength6(UINT i)
+{
+ if (i >= 1 && i <= 127)
+ {
+ return true;
+ }
+
+ return false;
+}
+
+// Get the process ID of the corresponding TCP connection by the socket
+UINT GetTcpProcessIdFromSocket(SOCK *s)
+{
+ LIST *o;
+ TCPTABLE *t;
+ UINT pid = 0;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return 0;
+ }
+
+ o = GetTcpTableList();
+ if (o == NULL)
+ {
+ return 0;
+ }
+
+ t = GetTcpTableFromEndPoint(o, &s->LocalIP, s->LocalPort,
+ &s->RemoteIP, s->RemotePort);
+
+ if (t != NULL)
+ {
+ pid = t->ProcessId;
+ }
+
+ FreeTcpTableList(o);
+
+ return pid;
+}
+UINT GetTcpProcessIdFromSocketReverse(SOCK *s)
+{
+ LIST *o;
+ TCPTABLE *t;
+ UINT pid = 0;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return 0;
+ }
+
+ o = GetTcpTableList();
+ if (o == NULL)
+ {
+ return 0;
+ }
+
+ t = GetTcpTableFromEndPoint(o, &s->RemoteIP, s->RemotePort,
+ &s->LocalIP, s->LocalPort);
+
+ if (t != NULL)
+ {
+ pid = t->ProcessId;
+ }
+
+ FreeTcpTableList(o);
+
+ return pid;
+}
+
+// Search in the TCP table by the end point
+TCPTABLE *GetTcpTableFromEndPoint(LIST *o, IP *local_ip, UINT local_port, IP *remote_ip, UINT remote_port)
+{
+ IP local;
+ UINT i;
+ // Validate arguments
+ if (o == NULL)
+ {
+ return NULL;
+ }
+
+ SetIP(&local, 127, 0, 0, 1);
+
+ if (local_ip == NULL)
+ {
+ local_ip = &local;
+ }
+
+ if (remote_ip == NULL)
+ {
+ remote_ip = &local;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ TCPTABLE *t = LIST_DATA(o, i);
+
+ if (t->Status == TCP_STATE_SYN_SENT || t->Status == TCP_STATE_SYN_RCVD ||
+ t->Status == TCP_STATE_ESTAB)
+ {
+ if (CmpIpAddr(&t->LocalIP, local_ip) == 0)
+ {
+ if (CmpIpAddr(&t->RemoteIP, remote_ip) == 0)
+ {
+ if (t->LocalPort == local_port)
+ {
+ if (t->RemotePort == remote_port)
+ {
+ return t;
+ }
+ }
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
+// Get the TCP table list (Win32)
+#ifdef OS_WIN32
+LIST *Win32GetTcpTableList()
+{
+ LIST *o;
+
+ // Windows XP SP2 or later
+ o = Win32GetTcpTableListByGetExtendedTcpTable();
+ if (o != NULL)
+ {
+ return o;
+ }
+
+ // Windows XP or later
+ o = Win32GetTcpTableListByAllocateAndGetTcpExTableFromStack();
+ if (o != NULL)
+ {
+ return o;
+ }
+
+ // For legacy Windows
+ return Win32GetTcpTableListByGetTcpTable();
+}
+
+// Get the TCP table list (for Windows XP SP2 or later)
+LIST *Win32GetTcpTableListByGetExtendedTcpTable()
+{
+ UINT need_size;
+ UINT i;
+ MIB_TCPTABLE_OWNER_PID *table;
+ bool ok = false;
+ LIST *o;
+ if (w32net->GetExtendedTcpTable == NULL)
+ {
+ return NULL;
+ }
+
+ for (i = 0;i < 128;i++)
+ {
+ UINT ret;
+ table = MallocFast(sizeof(MIB_TCPTABLE_OWNER_PID));
+ need_size = sizeof(MIB_TCPTABLE_OWNER_PID);
+ ret = w32net->GetExtendedTcpTable(table, &need_size, true, AF_INET, _TCP_TABLE_OWNER_PID_ALL, 0);
+ if (ret == NO_ERROR)
+ {
+ ok = true;
+ break;
+ }
+ else
+ {
+ Free(table);
+ if (ret != ERROR_INSUFFICIENT_BUFFER)
+ {
+ return NULL;
+ }
+ }
+
+ table = MallocFast(need_size);
+
+ ret = w32net->GetExtendedTcpTable(table, &need_size, true, AF_INET, _TCP_TABLE_OWNER_PID_ALL, 0);
+ if (ret == NO_ERROR)
+ {
+ ok = true;
+ break;
+ }
+ else
+ {
+ Free(table);
+
+ if (ret != ERROR_INSUFFICIENT_BUFFER)
+ {
+ return NULL;
+ }
+ }
+ }
+
+ if (ok == false)
+ {
+ return NULL;
+ }
+
+ o = NewListEx(NULL, true);
+
+ for (i = 0;i < table->dwNumEntries;i++)
+ {
+ MIB_TCPROW_OWNER_PID *r = &table->table[i];
+ TCPTABLE *t = ZeroMallocFast(sizeof(TCPTABLE));
+
+ UINTToIP(&t->LocalIP, r->dwLocalAddr);
+ t->LocalPort = Endian16((USHORT)r->dwLocalPort);
+
+ if (r->dwState != TCP_STATE_LISTEN)
+ {
+ UINTToIP(&t->RemoteIP, r->dwRemoteAddr);
+ t->RemotePort = Endian16((USHORT)r->dwRemotePort);
+ }
+
+ t->Status = r->dwState;
+ t->ProcessId = r->dwOwningPid;
+
+ Add(o, t);
+ }
+
+ Free(table);
+
+ return o;
+}
+
+// Get the TCP table list (Windows XP or later)
+LIST *Win32GetTcpTableListByAllocateAndGetTcpExTableFromStack()
+{
+ HANDLE heap;
+ UINT i;
+ MIB_TCPTABLE_OWNER_PID *table;
+ bool ok = false;
+ LIST *o;
+ if (w32net->AllocateAndGetTcpExTableFromStack == NULL)
+ {
+ return NULL;
+ }
+
+ heap = GetProcessHeap();
+
+ if (w32net->AllocateAndGetTcpExTableFromStack(&table, true, heap, HEAP_GROWABLE, AF_INET) != ERROR_SUCCESS)
+ {
+ return NULL;
+ }
+
+ o = NewListEx(NULL, true);
+
+ for (i = 0;i < table->dwNumEntries;i++)
+ {
+ MIB_TCPROW_OWNER_PID *r = &table->table[i];
+ TCPTABLE *t = ZeroMallocFast(sizeof(TCPTABLE));
+
+ UINTToIP(&t->LocalIP, r->dwLocalAddr);
+ t->LocalPort = Endian16((USHORT)r->dwLocalPort);
+
+ if (r->dwState != TCP_STATE_LISTEN)
+ {
+ UINTToIP(&t->RemoteIP, r->dwRemoteAddr);
+ t->RemotePort = Endian16((USHORT)r->dwRemotePort);
+ }
+
+ t->ProcessId = r->dwOwningPid;
+ t->Status = r->dwState;
+
+ Add(o, t);
+ }
+
+ HeapFree(heap, 0, table);
+
+ return o;
+}
+
+// Get the TCP table list (For legacy Windows)
+LIST *Win32GetTcpTableListByGetTcpTable()
+{
+ UINT need_size;
+ UINT i;
+ MIB_TCPTABLE *table;
+ bool ok = false;
+ LIST *o;
+ if (w32net->GetTcpTable == NULL)
+ {
+ return NULL;
+ }
+
+ for (i = 0;i < 128;i++)
+ {
+ UINT ret;
+ table = MallocFast(sizeof(MIB_TCPTABLE));
+ need_size = sizeof(MIB_TCPTABLE);
+ ret = w32net->GetTcpTable(table, &need_size, true);
+ if (ret == NO_ERROR)
+ {
+ ok = true;
+ break;
+ }
+ else
+ {
+ Free(table);
+ if (ret != ERROR_INSUFFICIENT_BUFFER)
+ {
+ return NULL;
+ }
+ }
+
+ table = MallocFast(need_size);
+
+ ret = w32net->GetTcpTable(table, &need_size, true);
+ if (ret == NO_ERROR)
+ {
+ ok = true;
+ break;
+ }
+ else
+ {
+ Free(table);
+
+ if (ret != ERROR_INSUFFICIENT_BUFFER)
+ {
+ return NULL;
+ }
+ }
+ }
+
+ if (ok == false)
+ {
+ return NULL;
+ }
+
+ o = NewListEx(NULL, true);
+
+ for (i = 0;i < table->dwNumEntries;i++)
+ {
+ MIB_TCPROW *r = &table->table[i];
+ TCPTABLE *t = ZeroMallocFast(sizeof(TCPTABLE));
+
+ UINTToIP(&t->LocalIP, r->dwLocalAddr);
+ t->LocalPort = Endian16((USHORT)r->dwLocalPort);
+
+ if (r->dwState != TCP_STATE_LISTEN)
+ {
+ UINTToIP(&t->RemoteIP, r->dwRemoteAddr);
+ t->RemotePort = Endian16((USHORT)r->dwRemotePort);
+ }
+
+ t->Status = r->dwState;
+
+ Add(o, t);
+ }
+
+ Free(table);
+
+ return o;
+}
+
+#endif // OS_WIN32
+
+// Display the TCP table
+void PrintTcpTableList(LIST *o)
+{
+ UINT i;
+ // Validate arguments
+ if (o == NULL)
+ {
+ Print("o == NULL\n\n");
+ return;
+ }
+
+ Print("--- TCPTABLE: %u Entries ---\n", LIST_NUM(o));
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ char tmp1[MAX_PATH], tmp2[MAX_PATH];
+ TCPTABLE *t = LIST_DATA(o, i);
+
+ IPToStr(tmp1, sizeof(tmp1), &t->LocalIP);
+ IPToStr(tmp2, sizeof(tmp2), &t->RemoteIP);
+
+ Print("%s:%u <--> %s:%u state=%u pid=%u\n",
+ tmp1, t->LocalPort,
+ tmp2, t->RemotePort,
+ t->Status,
+ t->ProcessId);
+ }
+ Print("------\n\n");
+}
+
+// Comparison of TCP table items
+int CompareTcpTable(void *p1, void *p2)
+{
+ TCPTABLE *t1, *t2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ t1 = *(TCPTABLE **)p1;
+ t2 = *(TCPTABLE **)p2;
+ if (t1 == NULL || t2 == NULL)
+ {
+ return 0;
+ }
+
+ return Cmp(t1, t2, sizeof(TCPTABLE));
+}
+
+// Get the TCP table list
+LIST *GetTcpTableList()
+{
+#ifdef OS_WIN32
+ return Win32GetTcpTableList();
+#else // OS_WIN32
+ return NULL;
+#endif // OS_WIN32
+}
+
+// Release the TCP table list
+void FreeTcpTableList(LIST *o)
+{
+ UINT i;
+ // Validate arguments
+ if (o == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ TCPTABLE *t = LIST_DATA(o, i);
+
+ Free(t);
+ }
+
+ ReleaseList(o);
+}
+
+// Get the number of clients connected from the specified IP address
+UINT GetNumIpClient(IP *ip)
+{
+ IP_CLIENT *c;
+ UINT ret = 0;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return 0;
+ }
+
+ LockList(ip_clients);
+ {
+ c = SearchIpClient(ip);
+
+ if (c != NULL)
+ {
+ ret = c->NumConnections;
+ }
+ }
+ UnlockList(ip_clients);
+
+ return ret;
+}
+
+// Add to the IP client entry
+void AddIpClient(IP *ip)
+{
+ IP_CLIENT *c;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ LockList(ip_clients);
+ {
+ c = SearchIpClient(ip);
+
+ if (c == NULL)
+ {
+ c = ZeroMallocFast(sizeof(IP_CLIENT));
+ Copy(&c->IpAddress, ip, sizeof(IP));
+ c->NumConnections = 0;
+
+ Add(ip_clients, c);
+ }
+
+ c->NumConnections++;
+ }
+ UnlockList(ip_clients);
+
+ //Debug("AddIpClient: %r\n", ip);
+}
+
+// Remove from the IP client list
+void DelIpClient(IP *ip)
+{
+ IP_CLIENT *c;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ LockList(ip_clients);
+ {
+ c = SearchIpClient(ip);
+
+ if (c != NULL)
+ {
+ c->NumConnections--;
+
+ if (c->NumConnections == 0)
+ {
+ Delete(ip_clients, c);
+ Free(c);
+ }
+ }
+ }
+ UnlockList(ip_clients);
+
+ //Debug("DelIpClient: %r\n", ip);
+}
+
+// Search for the IP client entry
+IP_CLIENT *SearchIpClient(IP *ip)
+{
+ IP_CLIENT t;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return NULL;
+ }
+
+ Zero(&t, sizeof(t));
+ Copy(&t.IpAddress, ip, sizeof(IP));
+
+ return Search(ip_clients, &t);
+}
+
+// Initialization of the client list
+void InitIpClientList()
+{
+ ip_clients = NewList(CompareIpClientList);
+}
+
+// Release of the client list
+void FreeIpClientList()
+{
+ UINT i;
+
+ for (i = 0;i < LIST_NUM(ip_clients);i++)
+ {
+ IP_CLIENT *c = LIST_DATA(ip_clients, i);
+
+ Free(c);
+ }
+
+ ReleaseList(ip_clients);
+ ip_clients = NULL;
+}
+
+// Comparison of the client list entries
+int CompareIpClientList(void *p1, void *p2)
+{
+ IP_CLIENT *c1, *c2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ c1 = *(IP_CLIENT **)p1;
+ c2 = *(IP_CLIENT **)p2;
+ if (c1 == NULL || c2 == NULL)
+ {
+ return 0;
+ }
+
+ return CmpIpAddr(&c1->IpAddress, &c2->IpAddress);
+}
+
+// Normalization of the MAC address
+bool NormalizeMacAddress(char *dst, UINT size, char *src)
+{
+ BUF *b;
+ bool ret = false;
+ // Validate arguments
+ if (dst == NULL || src == NULL)
+ {
+ return false;
+ }
+
+ b = StrToBin(src);
+
+ if (b != NULL && b->Size == 6)
+ {
+ ret = true;
+
+ BinToStr(dst, size, b->Buf, b->Size);
+ }
+
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Identify whether the IP address is empty
+bool IsZeroIP(IP *ip)
+{
+ return IsZeroIp(ip);
+}
+bool IsZeroIp(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return true;
+ }
+
+ if (IsIP6(ip) == false)
+ {
+ return IsZero(ip->addr, sizeof(ip->addr));
+ }
+ else
+ {
+ return IsZero(ip->ipv6_addr, sizeof(ip->ipv6_addr));
+ }
+}
+bool IsZeroIP6Addr(IPV6_ADDR *addr)
+{
+ // Validate arguments
+ if (addr == NULL)
+ {
+ return true;
+ }
+
+ return IsZero(addr, sizeof(IPV6_ADDR));
+}
+
+// Examine whether the specified IP address is meaningful as a host
+bool IsHostIPAddress4(IP *ip)
+{
+ UINT a;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ a = IPToUINT(ip);
+
+ if (a == 0 || a == 0xffffffff)
+ {
+ return false;
+ }
+
+ return true;
+}
+bool IsHostIPAddress32(UINT ip)
+{
+ IP p;
+
+ UINTToIP(&p, ip);
+
+ return IsHostIPAddress4(&p);
+}
+
+// Check whether the specified IP address and subnet mask indicates a network correctly
+bool IsNetworkAddress(IP *ip, IP *mask)
+{
+ if (IsIP4(ip))
+ {
+ return IsNetworkAddress4(ip, mask);
+ }
+ else
+ {
+ return IsNetworkAddress6(ip, mask);
+ }
+}
+bool IsNetworkAddress4(IP *ip, IP *mask)
+{
+ UINT a, b;
+ // Validate arguments
+ if (ip == NULL || mask == NULL)
+ {
+ return false;
+ }
+
+ if (IsIP4(ip) == false || IsIP4(mask) == false)
+ {
+ return false;
+ }
+
+ if (IsSubnetMask4(mask) == false)
+ {
+ return false;
+ }
+
+ a = IPToUINT(ip);
+ b = IPToUINT(mask);
+
+ if ((a & b) == a)
+ {
+ return true;
+ }
+
+ return false;
+}
+bool IsNetworkAddress32(UINT ip, UINT mask)
+{
+ IP a, b;
+
+ UINTToIP(&a, ip);
+ UINTToIP(&b, mask);
+
+ return IsNetworkAddress4(&a, &b);
+}
+
+// Convert the integer to a subnet mask
+UINT IntToSubnetMask32(UINT i)
+{
+ UINT ret = 0xFFFFFFFF;
+
+ 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;
+ }
+
+ if (IsLittleEndian())
+ {
+ ret = Swap32(ret);
+ }
+
+ return ret;
+}
+void IntToSubnetMask4(IP *ip, UINT i)
+{
+ UINT m;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ m = IntToSubnetMask32(i);
+
+ UINTToIP(ip, m);
+}
+
+// Examine whether the specified IP address is a subnet mask
+bool IsSubnetMask(IP *ip)
+{
+ if (IsIP6(ip))
+ {
+ return IsSubnetMask6(ip);
+ }
+ else
+ {
+ return IsSubnetMask4(ip);
+ }
+}
+bool IsSubnetMask4(IP *ip)
+{
+ UINT i;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if (IsIP6(ip))
+ {
+ return false;
+ }
+
+ i = IPToUINT(ip);
+
+ if (IsLittleEndian())
+ {
+ i = Swap32(i);
+ }
+
+ switch (i)
+ {
+ case 0x00000000:
+ case 0x80000000:
+ case 0xC0000000:
+ case 0xE0000000:
+ case 0xF0000000:
+ case 0xF8000000:
+ case 0xFC000000:
+ case 0xFE000000:
+ case 0xFF000000:
+ case 0xFF800000:
+ case 0xFFC00000:
+ case 0xFFE00000:
+ case 0xFFF00000:
+ case 0xFFF80000:
+ case 0xFFFC0000:
+ case 0xFFFE0000:
+ case 0xFFFF0000:
+ case 0xFFFF8000:
+ case 0xFFFFC000:
+ case 0xFFFFE000:
+ case 0xFFFFF000:
+ case 0xFFFFF800:
+ case 0xFFFFFC00:
+ case 0xFFFFFE00:
+ case 0xFFFFFF00:
+ case 0xFFFFFF80:
+ case 0xFFFFFFC0:
+ case 0xFFFFFFE0:
+ case 0xFFFFFFF0:
+ case 0xFFFFFFF8:
+ case 0xFFFFFFFC:
+ case 0xFFFFFFFE:
+ case 0xFFFFFFFF:
+ return true;
+ }
+
+ return false;
+}
+bool IsSubnetMask32(UINT ip)
+{
+ IP p;
+
+ UINTToIP(&p, ip);
+
+ return IsSubnetMask4(&p);
+}
+
+// Network release mode
+void SetNetworkReleaseMode()
+{
+ NetworkReleaseMode = true;
+}
+
+#ifdef OS_UNIX // Code for UNIX
+
+// Turn on and off the non-blocking mode of the socket
+void UnixSetSocketNonBlockingMode(int fd, bool nonblock)
+{
+ UINT flag = 0;
+ // Validate arguments
+ if (fd == INVALID_SOCKET)
+ {
+ return;
+ }
+
+ if (nonblock)
+ {
+ flag = 1;
+ }
+
+#ifdef FIONBIO
+ ioctl(fd, FIONBIO, &flag);
+#else // FIONBIO
+ {
+ int flag = fcntl(fd, F_GETFL, 0);
+ if (flag != -1)
+ {
+ if (nonblock)
+ {
+ flag |= O_NONBLOCK;
+ }
+ else
+ {
+ flag = flag & ~O_NONBLOCK;
+
+ fcntl(fd, F_SETFL, flag);
+ }
+ }
+ }
+#endif // FIONBIO
+}
+
+// Do Nothing
+void UnixIpForwardRowToRouteEntry(ROUTE_ENTRY *entry, void *ip_forward_row)
+{
+}
+
+// Do Nothing
+void UnixRouteEntryToIpForwardRow(void *ip_forward_row, ROUTE_ENTRY *entry)
+{
+}
+
+// Do Nothing
+int UnixCompareRouteEntryByMetric(void *p1, void *p2)
+{
+ return 1;
+}
+
+// Do Nothing
+ROUTE_TABLE *UnixGetRouteTable()
+{
+ ROUTE_TABLE *ret = ZeroMalloc(sizeof(ROUTE_TABLE));
+ ret->NumEntry = 0;
+ ret->Entry = ZeroMalloc(0);
+
+ return ret;
+}
+
+// Do Nothing
+bool UnixAddRouteEntry(ROUTE_ENTRY *e, bool *already_exists)
+{
+ return true;
+}
+
+// Do Nothing
+void UnixDeleteRouteEntry(ROUTE_ENTRY *e)
+{
+ return;
+}
+
+// Do Nothing
+UINT UnixGetVLanInterfaceID(char *instance_name)
+{
+ return 1;
+}
+
+// Do Nothing
+char **UnixEnumVLan(char *tag_name)
+{
+ char **list;
+
+ list = ZeroMalloc(sizeof(char *));
+
+ return list;
+}
+
+// Do Nothing
+void UnixRenewDhcp()
+{
+}
+
+// Get the IP address of the default DNS server
+bool UnixGetDefaultDns(IP *ip)
+{
+ BUF *b;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ Lock(unix_dns_server_addr_lock);
+ {
+ if (IsZero(&unix_dns_server, sizeof(IP)) == false)
+ {
+ Copy(ip, &unix_dns_server, sizeof(IP));
+ Unlock(unix_dns_server_addr_lock);
+ return true;
+ }
+
+ ip->addr[0] = 127;
+ ip->addr[1] = 0;
+ ip->addr[2] = 0;
+ ip->addr[3] = 1;
+
+ b = ReadDump("/etc/resolv.conf");
+ if (b != NULL)
+ {
+ char *s;
+ bool f = false;
+ while ((s = CfgReadNextLine(b)) != NULL)
+ {
+ TOKEN_LIST *t = ParseToken(s, "\" \t,");
+ if (t->NumTokens == 2)
+ {
+ if (StrCmpi(t->Token[0], "nameserver") == 0)
+ {
+ StrToIP(ip, t->Token[1]);
+ f = true;
+ }
+ }
+ FreeToken(t);
+
+ Free(s);
+
+ if (f)
+ {
+ break;
+ }
+ }
+ FreeBuf(b);
+ }
+ Copy(&unix_dns_server, ip, sizeof(IP));
+ }
+ Unlock(unix_dns_server_addr_lock);
+
+ return true;
+}
+
+
+// Select procedure
+void UnixSelect(SOCKSET *set, UINT timeout, CANCEL *c1, CANCEL *c2)
+{
+ UINT reads[MAXIMUM_WAIT_OBJECTS];
+ UINT writes[MAXIMUM_WAIT_OBJECTS];
+ UINT num_read, num_write, i;
+ UINT p1, p2;
+ SOCK_EVENT *sock_events[MAXIMUM_WAIT_OBJECTS];
+ UINT num_sock_events;
+ SOCK *s;
+ UCHAR tmp[MAX_SIZE];
+ int ret;
+ bool any_of_tubes_are_readable = false;
+ // Initialization of array
+ Zero(reads, sizeof(reads));
+ Zero(writes, sizeof(writes));
+ Zero(sock_events, sizeof(sock_events));
+ num_read = num_write = num_sock_events = 0;
+
+ // Setting the event array
+ if (set != NULL)
+ {
+ for (i = 0;i < set->NumSocket;i++)
+ {
+ s = set->Sock[i];
+ if (s != NULL)
+ {
+ UnixInitAsyncSocket(s);
+ if (s->Type == SOCK_INPROC)
+ {
+ TUBE *t = s->RecvTube;
+ if (t != NULL)
+ {
+ reads[num_read++] = t->SockEvent->pipe_read;
+
+ sock_events[num_sock_events++] = t->SockEvent;
+
+ if (t->SockEvent->current_pipe_data != 0)
+ {
+ any_of_tubes_are_readable = true;
+ }
+ }
+ }
+ else
+ {
+ if (s->NoNeedToRead == false)
+ {
+ reads[num_read++] = s->socket;
+ }
+ }
+
+ if (s->BulkRecvTube != NULL)
+ {
+ TUBE *t = s->BulkRecvTube;
+ if (t != NULL)
+ {
+ reads[num_read++] = t->SockEvent->pipe_read;
+
+ sock_events[num_sock_events++] = t->SockEvent;
+
+ if (t->SockEvent->current_pipe_data != 0)
+ {
+ any_of_tubes_are_readable = true;
+ }
+ }
+ }
+
+ if (s->WriteBlocked)
+ {
+ writes[num_write++] = s->socket;
+ }
+ }
+ }
+ }
+
+ if (timeout == 0)
+ {
+ return;
+ }
+
+ p1 = p2 = -1;
+
+ if (c1 != NULL)
+ {
+ reads[num_read++] = p1 = c1->pipe_read;
+ }
+ if (c2 != NULL)
+ {
+ reads[num_read++] = p2 = c2->pipe_read;
+ }
+
+ // Call the select
+ if (any_of_tubes_are_readable == false)
+ {
+ UnixSelectInner(num_read, reads, num_write, writes, timeout);
+ }
+
+ // Read from the pipe
+ if (c1 != NULL && c1->SpecialFlag == false && p1 != -1)
+ {
+ do
+ {
+ ret = read(p1, tmp, sizeof(tmp));
+ }
+ while (ret >= 1);
+ }
+ if (c2 != NULL && c2->SpecialFlag == false && p2 != -1)
+ {
+ do
+ {
+ ret = read(p2, tmp, sizeof(tmp));
+ }
+ while (ret >= 1);
+ }
+
+ // Read from the pipe of sockevent
+ for (i = 0;i < num_sock_events;i++)
+ {
+ SOCK_EVENT *e = sock_events[i];
+
+ e->current_pipe_data = 0;
+
+ do
+ {
+ ret = read(e->pipe_read, tmp, sizeof(tmp));
+ }
+ while (ret >= 1);
+ }
+}
+
+// Cancel
+void UnixCancel(CANCEL *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ UnixWritePipe(c->pipe_write);
+}
+
+// Release of the cancel object
+void UnixCleanupCancel(CANCEL *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ if (c->SpecialFlag == false)
+ {
+ UnixDeletePipe(c->pipe_read, c->pipe_write);
+ }
+
+ Free(c);
+}
+
+// Creating a new cancel object
+CANCEL *UnixNewCancel()
+{
+ CANCEL *c = ZeroMallocFast(sizeof(CANCEL));
+
+ c->ref = NewRef();
+ c->SpecialFlag = false;
+
+ UnixNewPipe(&c->pipe_read, &c->pipe_write);
+
+ return c;
+}
+
+// Add the socket to the socket event
+void UnixJoinSockToSockEvent(SOCK *sock, SOCK_EVENT *event)
+{
+ // Validate arguments
+ if (sock == NULL || event == NULL || sock->AsyncMode)
+ {
+ return;
+ }
+ if (sock->ListenMode != false || (sock->Type == SOCK_TCP && sock->Connected == false))
+ {
+ return;
+ }
+
+ sock->AsyncMode = true;
+
+ LockList(event->SockList);
+ {
+ Add(event->SockList, sock);
+ AddRef(sock->ref);
+ }
+ UnlockList(event->SockList);
+
+ // Make the socket asynchronous mode
+ if (sock->Type != SOCK_INPROC)
+ {
+ UnixSetSocketNonBlockingMode(sock->socket, true);
+ }
+
+ // Increase the reference count of the SOCK_EVENT
+ AddRef(event->ref);
+ sock->SockEvent = event;
+
+ // Set the socket event
+ SetSockEvent(event);
+}
+
+// Wait for a socket event
+bool UnixWaitSockEvent(SOCK_EVENT *event, UINT timeout)
+{
+ UINT num_read, num_write;
+ UINT *reads, *writes;
+ UINT n;
+ char tmp[MAX_SIZE];
+ int readret = 0;
+ bool event_pipe_is_readable = false;
+ // Validate arguments
+ if (event == NULL)
+ {
+ return false;
+ }
+
+ LockList(event->SockList);
+ {
+ UINT i;
+ reads = ZeroMallocFast(sizeof(SOCK *) * (LIST_NUM(event->SockList) + 1));
+
+ num_write = 0;
+ num_read = 0;
+
+ for (i = 0;i < LIST_NUM(event->SockList);i++)
+ {
+ SOCK *s = LIST_DATA(event->SockList, i);
+
+ if (s->NoNeedToRead == false)
+ {
+ reads[num_read++] = s->socket;
+ }
+
+ if (s->WriteBlocked)
+ {
+ num_write++;
+ }
+ }
+
+ reads[num_read++] = event->pipe_read;
+
+ if (event->current_pipe_data != 0)
+ {
+ event_pipe_is_readable = true;
+ }
+
+ writes = ZeroMallocFast(sizeof(SOCK *) * num_write);
+
+ n = 0;
+
+ for (i = 0;i < (num_read - 1);i++)
+ {
+ SOCK *s = LIST_DATA(event->SockList, i);
+ if (s->WriteBlocked)
+ {
+ writes[n++] = s->socket;
+ }
+ }
+ }
+ UnlockList(event->SockList);
+
+ if (event_pipe_is_readable == false)
+ {
+ UnixSelectInner(num_read, reads, num_write, writes, timeout);
+ }
+
+ event->current_pipe_data = 0;
+ do
+ {
+ readret = read(event->pipe_read, tmp, sizeof(tmp));
+ }
+ while (readret >= 1);
+
+ Free(reads);
+ Free(writes);
+
+ return true;
+}
+
+// Set the socket event
+void UnixSetSockEvent(SOCK_EVENT *event)
+{
+ // Validate arguments
+ if (event == NULL)
+ {
+ return;
+ }
+
+ if (event->current_pipe_data <= 100)
+ {
+ UnixWritePipe(event->pipe_write);
+ event->current_pipe_data++;
+ }
+}
+
+// Execute 'select' for the socket
+void UnixSelectInner(UINT num_read, UINT *reads, UINT num_write, UINT *writes, UINT timeout)
+{
+ struct pollfd *p;
+ UINT num;
+ UINT i;
+ UINT n;
+ UINT num_read_total, num_write_total;
+
+ if (num_read != 0 && reads == NULL)
+ {
+ num_read = 0;
+ }
+ if (num_write != 0 && writes == NULL)
+ {
+ num_write = 0;
+ }
+
+ if (timeout == 0)
+ {
+ return;
+ }
+
+ num_read_total = num_write_total = 0;
+ for (i = 0;i < num_read;i++)
+ {
+ if (reads[i] != INVALID_SOCKET)
+ {
+ num_read_total++;
+ }
+ }
+ for (i = 0;i < num_write;i++)
+ {
+ if (writes[i] != INVALID_SOCKET)
+ {
+ num_write_total++;
+ }
+ }
+
+ num = num_read_total + num_write_total;
+ p = ZeroMallocFast(sizeof(struct pollfd) * num);
+
+ n = 0;
+
+ for (i = 0;i < num_read;i++)
+ {
+ if (reads[i] != INVALID_SOCKET)
+ {
+ struct pollfd *pfd = &p[n++];
+ pfd->fd = reads[i];
+ pfd->events = POLLIN | POLLPRI | POLLERR | POLLHUP;
+ }
+ }
+
+ for (i = 0;i < num_write;i++)
+ {
+ if (writes[i] != INVALID_SOCKET)
+ {
+ struct pollfd *pfd = &p[n++];
+ pfd->fd = writes[i];
+ pfd->events = POLLIN | POLLPRI | POLLERR | POLLHUP | POLLOUT;
+ }
+ }
+
+ if (num != 0)
+ {
+ poll(p, num, timeout == INFINITE ? -1 : (int)timeout);
+ }
+ else
+ {
+ SleepThread(timeout);
+ }
+
+ Free(p);
+}
+
+// Clean-up of the socket event
+void UnixCleanupSockEvent(SOCK_EVENT *event)
+{
+ UINT i;
+ // Validate arguments
+ if (event == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(event->SockList);i++)
+ {
+ SOCK *s = LIST_DATA(event->SockList, i);
+
+ ReleaseSock(s);
+ }
+
+ ReleaseList(event->SockList);
+
+ UnixDeletePipe(event->pipe_read, event->pipe_write);
+
+ Free(event);
+}
+
+// Create a socket event
+SOCK_EVENT *UnixNewSockEvent()
+{
+ SOCK_EVENT *e = ZeroMallocFast(sizeof(SOCK_EVENT));
+
+ e->SockList = NewList(NULL);
+ e->ref = NewRef();
+
+ UnixNewPipe(&e->pipe_read, &e->pipe_write);
+
+ return e;
+}
+
+// Close the pipe
+void UnixDeletePipe(int p1, int p2)
+{
+ if (p1 != -1)
+ {
+ close(p1);
+ }
+
+ if (p2 != -1)
+ {
+ close(p2);
+ }
+}
+
+// Write to the pipe
+void UnixWritePipe(int pipe_write)
+{
+ char c = 1;
+ write(pipe_write, &c, 1);
+}
+
+// Create a new pipe
+void UnixNewPipe(int *pipe_read, int *pipe_write)
+{
+ int fd[2];
+ // Validate arguments
+ if (pipe_read == NULL || pipe_write == NULL)
+ {
+ return;
+ }
+
+ fd[0] = fd[1] = 0;
+
+ pipe(fd);
+
+ *pipe_read = fd[0];
+ *pipe_write = fd[1];
+
+ UnixSetSocketNonBlockingMode(*pipe_write, true);
+ UnixSetSocketNonBlockingMode(*pipe_read, true);
+}
+
+// Release the asynchronous socket
+void UnixFreeAsyncSocket(SOCK *sock)
+{
+ UINT p;
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+
+ Lock(sock->lock);
+ {
+ if (sock->AsyncMode == false)
+ {
+ Unlock(sock->lock);
+ return;
+ }
+
+ sock->AsyncMode = false;
+
+ // Examine whether this socket are associated to SockEvent
+ if (sock->SockEvent != NULL)
+ {
+ SOCK_EVENT *e = sock->SockEvent;
+
+ AddRef(e->ref);
+
+ p = e->pipe_write;
+ LockList(e->SockList);
+ {
+ if (Delete(e->SockList, sock))
+ {
+ ReleaseSock(sock);
+ }
+ }
+ UnlockList(e->SockList);
+
+ // Release the socket event
+ ReleaseSockEvent(sock->SockEvent);
+ sock->SockEvent = NULL;
+
+ SetSockEvent(e);
+
+ ReleaseSockEvent(e);
+ }
+ }
+ Unlock(sock->lock);
+}
+
+// Set the socket to asynchronous mode
+void UnixInitAsyncSocket(SOCK *sock)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+ if (sock->AsyncMode)
+ {
+ // The socket has been set in asynchronous mode already
+ return;
+ }
+ if (sock->ListenMode != false || ((sock->Type == SOCK_TCP || sock->Type == SOCK_INPROC) && sock->Connected == false))
+ {
+ return;
+ }
+
+ sock->AsyncMode = true;
+
+ if (sock->Type != SOCK_INPROC)
+ {
+ UnixSetSocketNonBlockingMode(sock->socket, true);
+ }
+}
+
+// Initializing the socket library
+void UnixInitSocketLibrary()
+{
+ // Do not do anything special
+}
+
+// Release of the socket library
+void UnixFreeSocketLibrary()
+{
+ // Do not do anything special
+}
+
+#endif // OS_UNIX
+
+#ifdef OS_WIN32 // Code for Windows
+
+NETWORK_WIN32_FUNCTIONS *w32net;
+
+// Comparison of IP_ADAPTER_INDEX_MAP
+int CompareIpAdapterIndexMap(void *p1, void *p2)
+{
+ IP_ADAPTER_INDEX_MAP *a1, *a2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ a1 = *(IP_ADAPTER_INDEX_MAP **)p1;
+ a2 = *(IP_ADAPTER_INDEX_MAP **)p2;
+ if (a1 == NULL || a2 == NULL)
+ {
+ return 0;
+ }
+
+ if (a1->Index > a2->Index)
+ {
+ return 1;
+ }
+ else if (a1->Index < a2->Index)
+ {
+ return -1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+// Update the IP address of the adapter
+bool Win32RenewAddressByGuid(char *guid)
+{
+ IP_ADAPTER_INDEX_MAP a;
+ // Validate arguments
+ if (guid == NULL)
+ {
+ return false;
+ }
+
+ Zero(&a, sizeof(a));
+ if (Win32GetAdapterFromGuid(&a, guid) == false)
+ {
+ return false;
+ }
+
+ return Win32RenewAddress(&a);
+}
+bool Win32RenewAddress(void *a)
+{
+ DWORD ret;
+ // Validate arguments
+ if (a == NULL)
+ {
+ return false;
+ }
+ if (w32net->IpRenewAddress == NULL)
+ {
+ return false;
+ }
+
+ ret = w32net->IpRenewAddress(a);
+
+ if (ret == NO_ERROR)
+ {
+ return true;
+ }
+ else
+ {
+ Debug("IpRenewAddress: Error: %u\n", ret);
+ return false;
+ }
+}
+
+// Release the IP address of the adapter
+bool Win32ReleaseAddress(void *a)
+{
+ DWORD ret;
+ // Validate arguments
+ if (a == NULL)
+ {
+ return false;
+ }
+ if (w32net->IpReleaseAddress == NULL)
+ {
+ return false;
+ }
+
+ ret = w32net->IpReleaseAddress(a);
+
+ if (ret == NO_ERROR)
+ {
+ return true;
+ }
+ else
+ {
+ Debug("IpReleaseAddress: Error: %u\n", ret);
+ return false;
+ }
+}
+bool Win32ReleaseAddressByGuid(char *guid)
+{
+ IP_ADAPTER_INDEX_MAP a;
+ // Validate arguments
+ if (guid == NULL)
+ {
+ return false;
+ }
+
+ Zero(&a, sizeof(a));
+ if (Win32GetAdapterFromGuid(&a, guid) == false)
+ {
+ return false;
+ }
+
+ return Win32ReleaseAddress(&a);
+}
+void Win32ReleaseAddressByGuidExThread(THREAD *t, void *param)
+{
+ WIN32_RELEASEADDRESS_THREAD_PARAM *p;
+ // Validate arguments
+ if (t == NULL || param == NULL)
+ {
+ return;
+ }
+
+ p = (WIN32_RELEASEADDRESS_THREAD_PARAM *)param;
+
+ AddRef(p->Ref);
+
+ NoticeThreadInit(t);
+
+ AddWaitThread(t);
+
+ if (p->Renew == false)
+ {
+ p->Ok = Win32ReleaseAddressByGuid(p->Guid);
+ }
+ else
+ {
+ p->Ok = Win32RenewAddressByGuid(p->Guid);
+ }
+
+ ReleaseWin32ReleaseAddressByGuidThreadParam(p);
+
+ DelWaitThread(t);
+}
+bool Win32RenewAddressByGuidEx(char *guid, UINT timeout)
+{
+ return Win32ReleaseOrRenewAddressByGuidEx(guid, timeout, true);
+}
+bool Win32ReleaseAddressByGuidEx(char *guid, UINT timeout)
+{
+ return Win32ReleaseOrRenewAddressByGuidEx(guid, timeout, false);
+}
+bool Win32ReleaseOrRenewAddressByGuidEx(char *guid, UINT timeout, bool renew)
+{
+ THREAD *t;
+ WIN32_RELEASEADDRESS_THREAD_PARAM *p;
+ bool ret = false;
+ UINT64 start_tick = 0;
+ UINT64 end_tick = 0;
+ // Validate arguments
+ if (guid == NULL)
+ {
+ return false;
+ }
+ if (timeout == 0)
+ {
+ timeout = INFINITE;
+ }
+
+ p = ZeroMalloc(sizeof(WIN32_RELEASEADDRESS_THREAD_PARAM));
+ p->Ref = NewRef();
+ StrCpy(p->Guid, sizeof(p->Guid), guid);
+ p->Timeout = timeout;
+ p->Renew = renew;
+
+ t = NewThread(Win32ReleaseAddressByGuidExThread, p);
+ WaitThreadInit(t);
+ start_tick = Tick64();
+ end_tick = start_tick + (UINT64)timeout;
+
+ while (true)
+ {
+ UINT64 now = Tick64();
+ UINT64 remain;
+ UINT remain32;
+
+ if (now >= end_tick)
+ {
+ break;
+ }
+
+ remain = end_tick - now;
+ remain32 = MIN((UINT)remain, 100);
+
+ if (WaitThread(t, remain32))
+ {
+ break;
+ }
+ }
+
+ ReleaseThread(t);
+
+ if (p->Ok)
+ {
+ ret = true;
+ }
+
+ ReleaseWin32ReleaseAddressByGuidThreadParam(p);
+
+ return ret;
+}
+void ReleaseWin32ReleaseAddressByGuidThreadParam(WIN32_RELEASEADDRESS_THREAD_PARAM *p)
+{
+ // Validate arguments
+ if (p == NULL)
+ {
+ return;
+ }
+
+ if (Release(p->Ref) == 0)
+ {
+ Free(p);
+ }
+}
+
+// Get the adapter by the GUID
+bool Win32GetAdapterFromGuid(void *a, char *guid)
+{
+ bool ret = false;
+ IP_INTERFACE_INFO *info;
+ UINT size;
+ int i;
+ LIST *o;
+ wchar_t tmp[MAX_SIZE];
+
+ // Validate arguments
+ if (a == NULL || guid == NULL)
+ {
+ return false;
+ }
+ if (w32net->GetInterfaceInfo == NULL)
+ {
+ return false;
+ }
+
+ UniFormat(tmp, sizeof(tmp), L"\\DEVICE\\TCPIP_%S", guid);
+
+ size = sizeof(IP_INTERFACE_INFO);
+ info = ZeroMallocFast(size);
+
+ if (w32net->GetInterfaceInfo(info, &size) == ERROR_INSUFFICIENT_BUFFER)
+ {
+ Free(info);
+ info = ZeroMallocFast(size);
+ }
+
+ if (w32net->GetInterfaceInfo(info, &size) != NO_ERROR)
+ {
+ Free(info);
+ return false;
+ }
+
+ o = NewListFast(CompareIpAdapterIndexMap);
+
+ for (i = 0;i < info->NumAdapters;i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i];
+
+ Add(o, a);
+ }
+
+ Sort(o);
+
+ for (i = 0;i < (int)(LIST_NUM(o));i++)
+ {
+ IP_ADAPTER_INDEX_MAP *e = LIST_DATA(o, i);
+
+ if (UniStrCmpi(e->Name, tmp) == 0)
+ {
+ Copy(a, e, sizeof(IP_ADAPTER_INDEX_MAP));
+ ret = true;
+ break;
+ }
+ }
+
+ ReleaseList(o);
+
+ Free(info);
+
+ return ret;
+}
+
+// Test
+void Win32NetworkTest()
+{
+ IP_INTERFACE_INFO *info;
+ UINT size;
+ int i;
+ LIST *o;
+
+ size = sizeof(IP_INTERFACE_INFO);
+ info = ZeroMallocFast(size);
+
+ if (w32net->GetInterfaceInfo(info, &size) == ERROR_INSUFFICIENT_BUFFER)
+ {
+ Free(info);
+ info = ZeroMallocFast(size);
+ }
+
+ if (w32net->GetInterfaceInfo(info, &size) != NO_ERROR)
+ {
+ Free(info);
+ return;
+ }
+
+ o = NewListFast(CompareIpAdapterIndexMap);
+
+ for (i = 0;i < info->NumAdapters;i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i];
+
+ Add(o, a);
+ }
+
+ Sort(o);
+
+ for (i = 0;i < (int)(LIST_NUM(o));i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = LIST_DATA(o, i);
+
+ DoNothing();
+ }
+
+ ReleaseList(o);
+
+ Free(info);
+}
+
+// Clear the DNS cache on Win32
+void Win32FlushDnsCache()
+{
+ Run("ipconfig.exe", "/flushdns", true, false);
+}
+
+// Update the DHCP address of the specified LAN card
+void Win32RenewDhcp9x(UINT if_id)
+{
+ IP_INTERFACE_INFO *info;
+ UINT size;
+ int i;
+ LIST *o;
+ // Validate arguments
+ if (if_id == 0)
+ {
+ return;
+ }
+
+ size = sizeof(IP_INTERFACE_INFO);
+ info = ZeroMallocFast(size);
+
+ if (w32net->GetInterfaceInfo(info, &size) == ERROR_INSUFFICIENT_BUFFER)
+ {
+ Free(info);
+ info = ZeroMallocFast(size);
+ }
+
+ if (w32net->GetInterfaceInfo(info, &size) != NO_ERROR)
+ {
+ Free(info);
+ return;
+ }
+
+ o = NewListFast(CompareIpAdapterIndexMap);
+
+ for (i = 0;i < info->NumAdapters;i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i];
+
+ Add(o, a);
+ }
+
+ Sort(o);
+
+ for (i = 0;i < (int)(LIST_NUM(o));i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = LIST_DATA(o, i);
+
+ if (a->Index == if_id)
+ {
+ char arg[MAX_PATH];
+ Format(arg, sizeof(arg), "/renew %u", i);
+ Run("ipconfig.exe", arg, true, false);
+ }
+ }
+
+ ReleaseList(o);
+
+ Free(info);
+}
+
+// Release the DHCP address of the specified LAN card
+void Win32ReleaseDhcp9x(UINT if_id, bool wait)
+{
+ IP_INTERFACE_INFO *info;
+ UINT size;
+ int i;
+ LIST *o;
+ // Validate arguments
+ if (if_id == 0)
+ {
+ return;
+ }
+
+ size = sizeof(IP_INTERFACE_INFO);
+ info = ZeroMallocFast(size);
+
+ if (w32net->GetInterfaceInfo(info, &size) == ERROR_INSUFFICIENT_BUFFER)
+ {
+ Free(info);
+ info = ZeroMallocFast(size);
+ }
+
+ if (w32net->GetInterfaceInfo(info, &size) != NO_ERROR)
+ {
+ Free(info);
+ return;
+ }
+
+ o = NewListFast(CompareIpAdapterIndexMap);
+
+ for (i = 0;i < info->NumAdapters;i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = &info->Adapter[i];
+
+ Add(o, a);
+ }
+
+ Sort(o);
+
+ for (i = 0;i < (int)(LIST_NUM(o));i++)
+ {
+ IP_ADAPTER_INDEX_MAP *a = LIST_DATA(o, i);
+
+ if (a->Index == if_id)
+ {
+ char arg[MAX_PATH];
+ Format(arg, sizeof(arg), "/release %u", i);
+ Run("ipconfig.exe", arg, true, wait);
+ }
+ }
+
+ ReleaseList(o);
+
+ Free(info);
+}
+
+// Re-obtain an IP address from a DHCP server
+void Win32RenewDhcp()
+{
+ if (OS_IS_WINDOWS_NT(GetOsInfo()->OsType))
+ {
+ Run("ipconfig.exe", "/renew", true, false);
+ if (MsIsVista())
+ {
+ Run("ipconfig.exe", "/renew6", true, false);
+ }
+ else
+ {
+ Run("netsh.exe", "int ipv6 renew", true, false);
+ }
+ }
+ else
+ {
+ Run("ipconfig.exe", "/renew_all", true, false);
+ }
+}
+
+// Enumerate a list of virtual LAN cards that contains the specified string
+char **Win32EnumVLan(char *tag_name)
+{
+ MIB_IFTABLE *p;
+ UINT ret;
+ UINT size_needed;
+ UINT num_retry = 0;
+ UINT i;
+ LIST *o;
+ char **ss;
+ // Validate arguments
+ if (tag_name == 0)
+ {
+ return NULL;
+ }
+
+RETRY:
+ p = ZeroMallocFast(sizeof(MIB_IFTABLE));
+ size_needed = 0;
+
+ // Examine the needed size
+ ret = w32net->GetIfTable(p, &size_needed, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER)
+ {
+ // Re-allocate the memory block of the needed size
+ Free(p);
+ p = ZeroMallocFast(size_needed);
+ }
+ else if (ret != NO_ERROR)
+ {
+ // Acquisition failure
+FAILED:
+ Free(p);
+ return NULL;
+ }
+
+ // Actually get
+ ret = w32net->GetIfTable(p, &size_needed, FALSE);
+ if (ret != NO_ERROR)
+ {
+ // Acquisition failure
+ if ((++num_retry) >= 5)
+ {
+ goto FAILED;
+ }
+ Free(p);
+ goto RETRY;
+ }
+
+ // Search
+ ret = 0;
+ o = NewListFast(CompareStr);
+ for (i = 0;i < p->dwNumEntries;i++)
+ {
+ MIB_IFROW *r = &p->table[i];
+ if (SearchStrEx(r->bDescr, tag_name, 0, false) != INFINITE)
+ {
+ char *s = CopyStr(r->bDescr);
+ Add(o, s);
+ }
+ }
+
+ Free(p);
+
+ // Sort
+ Sort(o);
+
+ // Convert to string
+ ss = ZeroMallocFast(sizeof(char *) * (LIST_NUM(o) + 1));
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ ss[i] = LIST_DATA(o, i);
+ }
+ ss[LIST_NUM(o)] = NULL;
+
+ ReleaseList(o);
+
+ return ss;
+}
+
+// Get the ID of the virtual LAN card from the instance name of the virtual LAN card
+UINT Win32GetVLanInterfaceID(char *instance_name)
+{
+ MIB_IFTABLE *p;
+ UINT ret;
+ UINT size_needed;
+ UINT num_retry = 0;
+ UINT i;
+ char ps_miniport_str[MAX_SIZE];
+ char ps_miniport_str2[MAX_SIZE];
+ UINT min_len = 0x7FFFFFFF;
+ // Validate arguments
+ if (instance_name == 0)
+ {
+ return 0;
+ }
+
+RETRY:
+ p = ZeroMallocFast(sizeof(MIB_IFTABLE));
+ size_needed = 0;
+
+ // Examine the needed size
+ ret = w32net->GetIfTable(p, &size_needed, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER)
+ {
+ // Re-allocate the memory block of the needed size
+ Free(p);
+ p = ZeroMallocFast(size_needed);
+ }
+ else if (ret != NO_ERROR)
+ {
+ // Acquisition failure
+FAILED:
+ Free(p);
+ Debug("******** GetIfTable Failed 1. Err = %u\n", ret);
+ return 0;
+ }
+
+ // Actually get
+ ret = w32net->GetIfTable(p, &size_needed, FALSE);
+ if (ret != NO_ERROR)
+ {
+ // Acquisition failure
+ if ((++num_retry) >= 5)
+ {
+ goto FAILED;
+ }
+ Free(p);
+ Debug("******** GetIfTable Failed 2. Err = %u\n", ret);
+ goto RETRY;
+ }
+
+ // "%s - Packet scheduler miniport"
+ Format(ps_miniport_str, sizeof(ps_miniport_str), "%s - ", instance_name);
+ Format(ps_miniport_str2, sizeof(ps_miniport_str2), "%s (Microsoft", instance_name);
+
+ // Search
+ ret = 0;
+ for (i = 0;i < p->dwNumEntries;i++)
+ {
+ MIB_IFROW *r = &p->table[i];
+ if (instance_name[0] != '@')
+ {
+ if (StrCmpi(r->bDescr, instance_name) == 0 || StartWith(r->bDescr, ps_miniport_str) || StartWith(r->bDescr, ps_miniport_str2))
+ {
+ UINT len = StrLen(r->bDescr);
+
+ if (len < min_len)
+ {
+ ret = r->dwIndex;
+
+ min_len = len;
+ }
+ }
+ }
+ else
+ {
+ if (SearchStrEx(r->bDescr, &instance_name[1], 0, false) != INFINITE)
+ {
+ ret = r->dwIndex;
+ }
+ }
+
+ //Debug("if[%u] (dwIndex=%u): %u, %s\n", i, r->dwIndex, r->dwType, r->bDescr);
+ }
+
+ Free(p);
+
+ return ret;
+}
+
+// Get the DNS suffix in another way
+bool Win32GetDnsSuffix(char *domain, UINT size)
+{
+ IP_ADAPTER_ADDRESSES_XP *info;
+ IP_ADAPTER_ADDRESSES_XP *cur;
+ UINT info_size;
+ bool ret = false;
+ // Validate arguments
+ ClearStr(domain, size);
+ if (domain == NULL)
+ {
+ return false;
+ }
+ if (w32net->GetAdaptersAddresses == NULL)
+ {
+ return false;
+ }
+
+ info_size = 0;
+ info = ZeroMalloc(sizeof(IP_ADAPTER_ADDRESSES_XP));
+ if (w32net->GetAdaptersAddresses(AF_INET, 0, NULL, info, &info_size) == ERROR_BUFFER_OVERFLOW)
+ {
+ Free(info);
+ info = ZeroMalloc(info_size);
+ }
+ if (w32net->GetAdaptersAddresses(AF_INET, 0, NULL, info, &info_size) != NO_ERROR)
+ {
+ Free(info);
+ return false;
+ }
+
+ cur = info;
+
+ while (cur != NULL)
+ {
+ if (UniIsEmptyStr(cur->DnsSuffix) == false)
+ {
+ UniToStr(domain, size, cur->DnsSuffix);
+ ret = true;
+ break;
+ }
+
+ cur = cur->Next;
+ }
+
+ Free(info);
+
+ return ret;
+}
+
+// Get the DNS server address of the default
+bool Win32GetDefaultDns(IP *ip, char *domain, UINT size)
+{
+ FIXED_INFO *info;
+ UINT info_size;
+ char *dns_name;
+ // Validate arguments
+ ClearStr(domain, size);
+ if (ip == NULL)
+ {
+ return false;
+ }
+ Zero(ip, sizeof(IP));
+ if (w32net->GetNetworkParams == NULL)
+ {
+ return false;
+ }
+ info_size = 0;
+ info = ZeroMallocFast(sizeof(FIXED_INFO));
+ if (w32net->GetNetworkParams(info, &info_size) == ERROR_BUFFER_OVERFLOW)
+ {
+ Free(info);
+ info = ZeroMallocFast(info_size);
+ }
+ if (w32net->GetNetworkParams(info, &info_size) != NO_ERROR)
+ {
+ Free(info);
+ return false;
+ }
+
+ if (info->DnsServerList.IpAddress.String == NULL)
+ {
+ Free(info);
+ return false;
+ }
+
+ dns_name = info->DnsServerList.IpAddress.String;
+ StrToIP(ip, dns_name);
+
+ if (domain != NULL)
+ {
+ StrCpy(domain, size, info->DomainName);
+ Trim(domain);
+ }
+
+ Free(info);
+
+ return true;
+}
+
+// IP conversion function for Win32
+void Win32UINTToIP(IP *ip, UINT i)
+{
+ UINTToIP(ip, i);
+}
+
+// IP conversion function for Win32
+UINT Win32IPToUINT(IP *ip)
+{
+ return IPToUINT(ip);
+}
+
+// Remove a routing entry from the routing table
+void Win32DeleteRouteEntry(ROUTE_ENTRY *e)
+{
+ MIB_IPFORWARDROW *p;
+ // Validate arguments
+ if (e == NULL)
+ {
+ return;
+ }
+
+ p = ZeroMallocFast(sizeof(MIB_IPFORWARDROW));
+ Win32RouteEntryToIpForwardRow(p, e);
+
+ // Delete
+ w32net->DeleteIpForwardEntry(p);
+
+ Free(p);
+}
+
+// Add a routing entry to the routing table
+bool Win32AddRouteEntry(ROUTE_ENTRY *e, bool *already_exists)
+{
+ bool ret = false;
+ bool dummy = false;
+ MIB_IPFORWARDROW *p;
+ UINT err = 0;
+ // Validate arguments
+ if (e == NULL)
+ {
+ return false;
+ }
+ if (already_exists == NULL)
+ {
+ already_exists = &dummy;
+ }
+
+ *already_exists = false;
+
+ p = ZeroMallocFast(sizeof(MIB_IPFORWARDROW));
+ Win32RouteEntryToIpForwardRow(p, e);
+
+ // Adding
+ err = w32net->CreateIpForwardEntry(p);
+ if (err != 0)
+ {
+ if (err == ERROR_OBJECT_ALREADY_EXISTS)
+ {
+ Debug("CreateIpForwardEntry: Already Exists\n");
+ *already_exists = true;
+ ret = true;
+ }
+ else
+ {
+ Debug("CreateIpForwardEntry Error: %u\n", err);
+ ret = false;
+ }
+ }
+ else
+ {
+ ret = true;
+ }
+
+ Free(p);
+
+ return ret;
+}
+
+// Get the routing table
+ROUTE_TABLE *Win32GetRouteTable()
+{
+ ROUTE_TABLE *t = ZeroMallocFast(sizeof(ROUTE_TABLE));
+ MIB_IPFORWARDTABLE *p;
+ UINT ret;
+ UINT size_needed;
+ UINT num_retry = 0;
+ LIST *o;
+ UINT i;
+ ROUTE_ENTRY *e;
+
+RETRY:
+ p = ZeroMallocFast(sizeof(MIB_IFTABLE));
+ size_needed = 0;
+
+ // Examine the needed size
+ ret = w32net->GetIpForwardTable(p, &size_needed, 0);
+ if (ret == ERROR_INSUFFICIENT_BUFFER)
+ {
+ // Re-allocate the memory block of the needed size
+ Free(p);
+ p = ZeroMallocFast(size_needed);
+ }
+ else if (ret != NO_ERROR)
+ {
+ // Acquisition failure
+FAILED:
+ Free(p);
+ t->Entry = MallocFast(0);
+ return t;
+ }
+
+ // Actually get
+ ret = w32net->GetIpForwardTable(p, &size_needed, FALSE);
+ if (ret != NO_ERROR)
+ {
+ // Acquisition failure
+ if ((++num_retry) >= 5)
+ {
+ goto FAILED;
+ }
+ Free(p);
+ goto RETRY;
+ }
+
+ // Add to the list along
+ o = NewListFast(Win32CompareRouteEntryByMetric);
+ for (i = 0;i < p->dwNumEntries;i++)
+ {
+ e = ZeroMallocFast(sizeof(ROUTE_ENTRY));
+ Win32IpForwardRowToRouteEntry(e, &p->table[i]);
+ Add(o, e);
+ }
+ Free(p);
+
+ // Sort by metric
+ Sort(o);
+
+ // Combine the results
+ t->NumEntry = LIST_NUM(o);
+ t->Entry = ToArrayEx(o, true);
+ ReleaseList(o);
+
+ return t;
+}
+
+// Sort the routing entries by metric
+int Win32CompareRouteEntryByMetric(void *p1, void *p2)
+{
+ ROUTE_ENTRY *e1, *e2;
+ // Validate arguments
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+
+ e1 = *(ROUTE_ENTRY **)p1;
+ e2 = *(ROUTE_ENTRY **)p2;
+ if (e1 == NULL || e2 == NULL)
+ {
+ return 0;
+ }
+
+ if (e1->Metric > e2->Metric)
+ {
+ return 1;
+ }
+ else if (e1->Metric == e2->Metric)
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+
+// Convert the ROUTE_ENTRY to a MIB_IPFORWARDROW
+void Win32RouteEntryToIpForwardRow(void *ip_forward_row, ROUTE_ENTRY *entry)
+{
+ MIB_IPFORWARDROW *r;
+ // Validate arguments
+ if (entry == NULL || ip_forward_row == NULL)
+ {
+ return;
+ }
+
+ r = (MIB_IPFORWARDROW *)ip_forward_row;
+ Zero(r, sizeof(MIB_IPFORWARDROW));
+
+ // IP address
+ r->dwForwardDest = Win32IPToUINT(&entry->DestIP);
+ // Subnet mask
+ r->dwForwardMask = Win32IPToUINT(&entry->DestMask);
+ // Gateway IP address
+ r->dwForwardNextHop = Win32IPToUINT(&entry->GatewayIP);
+ // Local routing flag
+ if (entry->LocalRouting)
+ {
+ // Local
+ r->dwForwardType = 3;
+ }
+ else
+ {
+ // Remote router
+ r->dwForwardType = 4;
+ }
+ // Protocol
+ r->dwForwardProto = r->dwForwardType - 1; // Subtract by 1 in most cases
+ if (entry->PPPConnection)
+ {
+ // Isn't this a PPP? Danger!
+ r->dwForwardProto++;
+ }
+ // Metric
+ r->dwForwardMetric1 = entry->Metric;
+
+ if (MsIsVista() == false)
+ {
+ r->dwForwardMetric2 = r->dwForwardMetric3 = r->dwForwardMetric4 = r->dwForwardMetric5 = INFINITE;
+ }
+ else
+ {
+ r->dwForwardMetric2 = r->dwForwardMetric3 = r->dwForwardMetric4 = r->dwForwardMetric5 = 0;
+ r->dwForwardAge = 163240;
+ }
+
+ // Interface ID
+ r->dwForwardIfIndex = entry->InterfaceID;
+
+ Debug("Win32RouteEntryToIpForwardRow()\n");
+ Debug(" r->dwForwardDest=%X\n", r->dwForwardDest);
+ Debug(" r->dwForwardMask=%X\n", r->dwForwardMask);
+ Debug(" r->dwForwardNextHop=%X\n", r->dwForwardNextHop);
+ Debug(" r->dwForwardType=%u\n", r->dwForwardType);
+ Debug(" r->dwForwardProto=%u\n", r->dwForwardProto);
+ Debug(" r->dwForwardMetric1=%u\n", r->dwForwardMetric1);
+ Debug(" r->dwForwardMetric2=%u\n", r->dwForwardMetric2);
+ Debug(" r->dwForwardIfIndex=%u\n", r->dwForwardIfIndex);
+}
+
+// Convert the MIB_IPFORWARDROW to a ROUTE_ENTRY
+void Win32IpForwardRowToRouteEntry(ROUTE_ENTRY *entry, void *ip_forward_row)
+{
+ MIB_IPFORWARDROW *r;
+ // Validate arguments
+ if (entry == NULL || ip_forward_row == NULL)
+ {
+ return;
+ }
+
+ r = (MIB_IPFORWARDROW *)ip_forward_row;
+
+ Zero(entry, sizeof(ROUTE_ENTRY));
+ // IP address
+ Win32UINTToIP(&entry->DestIP, r->dwForwardDest);
+ // Subnet mask
+ Win32UINTToIP(&entry->DestMask, r->dwForwardMask);
+ // Gateway IP address
+ Win32UINTToIP(&entry->GatewayIP, r->dwForwardNextHop);
+ // Local routing flag
+ if (r->dwForwardType == 3)
+ {
+ entry->LocalRouting = true;
+ }
+ else
+ {
+ entry->LocalRouting = false;
+ }
+ if (entry->LocalRouting && r->dwForwardProto == 3)
+ {
+ // PPP. Danger!
+ entry->PPPConnection = true;
+ }
+ // Metric
+ entry->Metric = r->dwForwardMetric1;
+ // Interface ID
+ entry->InterfaceID = r->dwForwardIfIndex;
+}
+
+// Initializing the socket library
+void Win32InitSocketLibrary()
+{
+ WSADATA data;
+ Zero(&data, sizeof(data));
+ WSAStartup(MAKEWORD(2, 2), &data);
+
+ // Load the DLL functions
+ w32net = ZeroMalloc(sizeof(NETWORK_WIN32_FUNCTIONS));
+ w32net->hIpHlpApi32 = LoadLibrary("iphlpapi.dll");
+ w32net->hIcmp = LoadLibrary("icmp.dll");
+
+ if (w32net->hIpHlpApi32 != NULL)
+ {
+ w32net->CreateIpForwardEntry =
+ (DWORD (__stdcall *)(PMIB_IPFORWARDROW))
+ GetProcAddress(w32net->hIpHlpApi32, "CreateIpForwardEntry");
+
+ w32net->DeleteIpForwardEntry =
+ (DWORD (__stdcall *)(PMIB_IPFORWARDROW))
+ GetProcAddress(w32net->hIpHlpApi32, "DeleteIpForwardEntry");
+
+ w32net->GetIfTable =
+ (DWORD (__stdcall *)(PMIB_IFTABLE, PULONG, BOOL))
+ GetProcAddress(w32net->hIpHlpApi32, "GetIfTable");
+
+ w32net->GetIfTable2 =
+ (DWORD (__stdcall *)(void **))
+ GetProcAddress(w32net->hIpHlpApi32, "GetIfTable2");
+
+ w32net->FreeMibTable =
+ (void (__stdcall *)(PVOID))
+ GetProcAddress(w32net->hIpHlpApi32, "FreeMibTable");
+
+ w32net->GetIpForwardTable =
+ (DWORD (__stdcall *)(PMIB_IPFORWARDTABLE, PULONG, BOOL))
+ GetProcAddress(w32net->hIpHlpApi32, "GetIpForwardTable");
+
+ w32net->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");
+
+ w32net->IpRenewAddress =
+ (DWORD (__stdcall *)(PIP_ADAPTER_INDEX_MAP))
+ GetProcAddress(w32net->hIpHlpApi32, "IpRenewAddress");
+
+ w32net->IpReleaseAddress =
+ (DWORD (__stdcall *)(PIP_ADAPTER_INDEX_MAP))
+ GetProcAddress(w32net->hIpHlpApi32, "IpReleaseAddress");
+
+ w32net->GetInterfaceInfo =
+ (DWORD (__stdcall *)(PIP_INTERFACE_INFO, PULONG))
+ GetProcAddress(w32net->hIpHlpApi32, "GetInterfaceInfo");
+
+ w32net->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");
+
+ w32net->AllocateAndGetTcpExTableFromStack =
+ (DWORD (__stdcall *)(PVOID *,BOOL,HANDLE,DWORD,DWORD))
+ GetProcAddress(w32net->hIpHlpApi32, "AllocateAndGetTcpExTableFromStack");
+
+ w32net->GetTcpTable =
+ (DWORD (__stdcall *)(PMIB_TCPTABLE,PDWORD,BOOL))
+ GetProcAddress(w32net->hIpHlpApi32, "GetTcpTable");
+
+ w32net->NotifyRouteChange =
+ (DWORD (__stdcall *)(PHANDLE,LPOVERLAPPED))
+ GetProcAddress(w32net->hIpHlpApi32, "NotifyRouteChange");
+
+ w32net->CancelIPChangeNotify =
+ (BOOL (__stdcall *)(LPOVERLAPPED))
+ GetProcAddress(w32net->hIpHlpApi32, "CancelIPChangeNotify");
+
+ w32net->NhpAllocateAndGetInterfaceInfoFromStack =
+ (DWORD (__stdcall *)(IP_INTERFACE_NAME_INFO **,PDWORD,BOOL,HANDLE,DWORD))
+ GetProcAddress(w32net->hIpHlpApi32, "NhpAllocateAndGetInterfaceInfoFromStack");
+
+ w32net->IcmpCreateFile =
+ (HANDLE (__stdcall *)())
+ GetProcAddress(w32net->hIpHlpApi32, "IcmpCreateFile");
+
+ w32net->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");
+ }
+
+ if (w32net->hIcmp != NULL)
+ {
+ if (w32net->IcmpCreateFile == NULL || w32net->IcmpCloseHandle == NULL || w32net->IcmpSendEcho == NULL)
+ {
+ w32net->IcmpCreateFile =
+ (HANDLE (__stdcall *)())
+ GetProcAddress(w32net->hIcmp, "IcmpCreateFile");
+
+ w32net->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");
+ }
+ }
+
+ if (w32net->IcmpCreateFile == NULL || w32net->IcmpCloseHandle == NULL || w32net->IcmpSendEcho == NULL)
+ {
+ w32net->IcmpCreateFile = NULL;
+ w32net->IcmpCloseHandle = NULL;
+ w32net->IcmpSendEcho = NULL;
+ }
+}
+
+// Release of the socket library
+void Win32FreeSocketLibrary()
+{
+ if (w32net != NULL)
+ {
+ if (w32net->hIpHlpApi32 != NULL)
+ {
+ FreeLibrary(w32net->hIpHlpApi32);
+ }
+
+ if (w32net->hIcmp != NULL)
+ {
+ FreeLibrary(w32net->hIcmp);
+ }
+
+ Free(w32net);
+ w32net = NULL;
+ }
+
+ WSACleanup();
+}
+
+// Cancel
+void Win32Cancel(CANCEL *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ SetEvent((HANDLE)c->hEvent);
+}
+
+// Cleanup of the cancel object
+void Win32CleanupCancel(CANCEL *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ if (c->SpecialFlag == false)
+ {
+ CloseHandle(c->hEvent);
+ }
+
+ Free(c);
+}
+
+// New cancel object
+CANCEL *Win32NewCancel()
+{
+ CANCEL *c = ZeroMallocFast(sizeof(CANCEL));
+ c->ref = NewRef();
+ c->SpecialFlag = false;
+ c->hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+
+ return c;
+}
+
+// Waiting for a socket event
+bool Win32WaitSockEvent(SOCK_EVENT *event, UINT timeout)
+{
+ // Validate arguments
+ if (event == NULL || timeout == 0)
+ {
+ return false;
+ }
+
+ if (WaitForSingleObject((HANDLE)event->hEvent, timeout) == WAIT_OBJECT_0)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+}
+
+// Clean-up of the socket event
+void Win32CleanupSockEvent(SOCK_EVENT *event)
+{
+ // Validate arguments
+ if (event == NULL)
+ {
+ return;
+ }
+
+ CloseHandle((HANDLE)event->hEvent);
+
+ Free(event);
+}
+
+// Set of the socket event
+void Win32SetSockEvent(SOCK_EVENT *event)
+{
+ // Validate arguments
+ if (event == NULL)
+ {
+ return;
+ }
+
+ SetEvent((HANDLE)event->hEvent);
+}
+
+// Creating a socket event
+SOCK_EVENT *Win32NewSockEvent()
+{
+ SOCK_EVENT *e = ZeroMallocFast(sizeof(SOCK_EVENT));
+
+ e->ref = NewRef();
+ e->hEvent = (void *)CreateEvent(NULL, FALSE, FALSE, NULL);
+
+ return e;
+}
+
+// Associate the socket with socket event and set it to asynchronous mode
+void Win32JoinSockToSockEvent(SOCK *sock, SOCK_EVENT *event)
+{
+ HANDLE hEvent;
+ // Validate arguments
+ if (sock == NULL || event == NULL || sock->AsyncMode)
+ {
+ return;
+ }
+ if (sock->ListenMode != false || (sock->Type != SOCK_UDP && sock->Connected == false))
+ {
+ return;
+ }
+
+ sock->AsyncMode = true;
+
+ hEvent = event->hEvent;
+
+ // Association
+ WSAEventSelect(sock->socket, hEvent, FD_READ | FD_WRITE | FD_CLOSE);
+
+ // Increase the reference count of the SOCK_EVENT
+ AddRef(event->ref);
+ sock->SockEvent = event;
+}
+
+// Set the socket to asynchronous mode
+void Win32InitAsyncSocket(SOCK *sock)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+ if (sock->AsyncMode)
+ {
+ // This socket is already in asynchronous mode
+ return;
+ }
+ if (sock->ListenMode || ((sock->Type == SOCK_TCP || sock->Type == SOCK_INPROC) && sock->Connected == false))
+ {
+ return;
+ }
+
+ sock->AsyncMode = true;
+
+ if (sock->Type == SOCK_INPROC)
+ {
+ // Fetch the event of the TUBE
+ TUBE *t = sock->RecvTube;
+
+ if (t != NULL)
+ {
+ if (t->SockEvent != NULL)
+ {
+ sock->hEvent = t->SockEvent->hEvent;
+ }
+ }
+ }
+ else
+ {
+ // Creating an Event
+ sock->hEvent = (void *)CreateEvent(NULL, FALSE, FALSE, NULL);
+
+ // Association
+ WSAEventSelect(sock->socket, sock->hEvent, FD_READ | FD_WRITE | FD_CLOSE);
+ }
+}
+
+// Release the asynchronous socket
+void Win32FreeAsyncSocket(SOCK *sock)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+
+ // Asynchronous socket
+ if (sock->hEvent != NULL)
+ {
+ if (sock->Type != SOCK_INPROC)
+ {
+ CloseHandle((HANDLE)sock->hEvent);
+ }
+ }
+ sock->hEvent = NULL;
+ sock->AsyncMode = false;
+
+ // Socket event
+ if (sock->SockEvent != NULL)
+ {
+ ReleaseSockEvent(sock->SockEvent);
+ sock->SockEvent = NULL;
+ }
+}
+
+// Select function for Win32
+void Win32Select(SOCKSET *set, UINT timeout, CANCEL *c1, CANCEL *c2)
+{
+ HANDLE array[MAXIMUM_WAIT_OBJECTS];
+ UINT n, i;
+ SOCK *s;
+ // Initialization of array
+ Zero(array, sizeof(array));
+ n = 0;
+
+ // Setting the event array
+ if (set != NULL)
+ {
+ for (i = 0;i < set->NumSocket;i++)
+ {
+ s = set->Sock[i];
+ if (s != NULL)
+ {
+ Win32InitAsyncSocket(s);
+ if (s->hEvent != NULL)
+ {
+ array[n++] = (HANDLE)s->hEvent;
+ }
+
+ if (s->BulkRecvTube != NULL)
+ {
+ array[n++] = (HANDLE)s->BulkRecvTube->SockEvent->hEvent;
+ }
+ }
+ }
+ }
+ if (c1 != NULL && c1->hEvent != NULL)
+ {
+ array[n++] = c1->hEvent;
+ }
+ if (c2 != NULL && c2->hEvent != NULL)
+ {
+ array[n++] = c2->hEvent;
+ }
+
+ if (timeout == 0)
+ {
+ return;
+ }
+
+ if (n == 0)
+ {
+ // Call normal waiting function if no events to wait are registered
+ SleepThread(timeout);
+ }
+ else
+ {
+ // Wait for the event if events are registered at least one
+ if (n == 1)
+ {
+ // Calling a lightweight version If the event is only one
+ WaitForSingleObject(array[0], timeout);
+ }
+ else
+ {
+ // In case of multiple events
+ WaitForMultipleObjects(n, array, false, timeout);
+ }
+ }
+}
+
+#endif // OS_WIN32
+
+// Check whether the IPv6 is supported
+bool IsIPv6Supported()
+{
+#ifdef NO_IPV6
+ return false;
+#else // NO_IPV6
+ SOCKET s;
+
+ s = socket(AF_INET6, SOCK_STREAM, 0);
+ if (s == INVALID_SOCKET)
+ {
+ return false;
+ }
+
+ closesocket(s);
+
+ return true;
+#endif // NO_IPV6
+}
+
+// Get the host name from the host cache
+bool GetHostCache(char *hostname, UINT size, IP *ip)
+{
+ bool ret;
+ // Validate arguments
+ if (hostname == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ ret = false;
+
+ LockList(HostCacheList);
+ {
+ HOSTCACHE t, *c;
+ Zero(&t, sizeof(t));
+ Copy(&t.IpAddress, ip, sizeof(IP));
+
+ c = Search(HostCacheList, &t);
+ if (c != NULL)
+ {
+ if (IsEmptyStr(c->HostName) == false)
+ {
+ ret = true;
+ StrCpy(hostname, size, c->HostName);
+ }
+ else
+ {
+ ret = true;
+ StrCpy(hostname, size, "");
+ }
+ }
+ }
+ UnlockList(HostCacheList);
+
+ return ret;
+}
+
+// Add to the host name cache
+void AddHostCache(IP *ip, char *hostname)
+{
+ // Validate arguments
+ if (ip == NULL || hostname == NULL)
+ {
+ return;
+ }
+ if (IsNetworkNameCacheEnabled() == false)
+ {
+ return;
+ }
+
+ LockList(HostCacheList);
+ {
+ HOSTCACHE t, *c;
+ UINT i;
+ LIST *o;
+
+ Zero(&t, sizeof(t));
+ Copy(&t.IpAddress, ip, sizeof(IP));
+
+ c = Search(HostCacheList, &t);
+ if (c == NULL)
+ {
+ c = ZeroMalloc(sizeof(HOSTCACHE));
+ Copy(&c->IpAddress, ip, sizeof(IP));
+ Add(HostCacheList, c);
+ }
+
+ StrCpy(c->HostName, sizeof(c->HostName), hostname);
+ c->Expires = Tick64() + (UINT64)EXPIRES_HOSTNAME;
+
+ o = NewListFast(NULL);
+
+ for (i = 0;i < LIST_NUM(HostCacheList);i++)
+ {
+ HOSTCACHE *c = LIST_DATA(HostCacheList, i);
+
+ if (c->Expires <= Tick64())
+ {
+ Add(o, c);
+ }
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ HOSTCACHE *c = LIST_DATA(o, i);
+
+ if (Delete(HostCacheList, c))
+ {
+ Free(c);
+ }
+ }
+
+ ReleaseList(o);
+ }
+ UnlockList(HostCacheList);
+}
+
+// Comparison of host name cache entries
+int CompareHostCache(void *p1, void *p2)
+{
+ HOSTCACHE *c1, *c2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ c1 = *(HOSTCACHE **)p1;
+ c2 = *(HOSTCACHE **)p2;
+ if (c1 == NULL || c2 == NULL)
+ {
+ return 0;
+ }
+
+ return CmpIpAddr(&c1->IpAddress, &c2->IpAddress);
+}
+
+// Release of the host name cache
+void FreeHostCache()
+{
+ UINT i;
+
+ for (i = 0;i < LIST_NUM(HostCacheList);i++)
+ {
+ HOSTCACHE *c = LIST_DATA(HostCacheList, i);
+
+ Free(c);
+ }
+
+ ReleaseList(HostCacheList);
+ HostCacheList = NULL;
+}
+
+// Initialization of the host name cache
+void InitHostCache()
+{
+ HostCacheList = NewList(CompareHostCache);
+}
+
+// Add the thread to the thread waiting list
+void AddWaitThread(THREAD *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ AddRef(t->ref);
+
+ LockList(WaitThreadList);
+ {
+ Add(WaitThreadList, t);
+ }
+ UnlockList(WaitThreadList);
+}
+
+// Remove the thread from the waiting list
+void DelWaitThread(THREAD *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ LockList(WaitThreadList);
+ {
+ if (Delete(WaitThreadList, t))
+ {
+ ReleaseThread(t);
+ }
+ }
+ UnlockList(WaitThreadList);
+}
+
+// Creating a thread waiting list
+void InitWaitThread()
+{
+ WaitThreadList = NewList(NULL);
+}
+
+// Release of the thread waiting list
+void FreeWaitThread()
+{
+ UINT i, num;
+ THREAD **threads;
+
+ LockList(WaitThreadList);
+ {
+ num = LIST_NUM(WaitThreadList);
+ threads = ToArray(WaitThreadList);
+ DeleteAll(WaitThreadList);
+ }
+ UnlockList(WaitThreadList);
+
+ for (i = 0;i < num;i++)
+ {
+ THREAD *t = threads[i];
+ WaitThread(t, INFINITE);
+ ReleaseThread(t);
+ }
+
+ Free(threads);
+
+ ReleaseList(WaitThreadList);
+ WaitThreadList = NULL;
+}
+
+// Check the cipher list name
+bool CheckCipherListName(char *name)
+{
+ UINT i;
+ // Validate arguments
+ if (name == NULL)
+ {
+ return false;
+ }
+
+ for (i = 0;i < cipher_list_token->NumTokens;i++)
+ {
+ if (StrCmpi(cipher_list_token->Token[i], name) == 0)
+ {
+ return true;
+ }
+ }
+
+ return false;
+}
+
+// Renewing the IP address of the DHCP server
+void RenewDhcp()
+{
+#ifdef OS_WIN32
+ Win32RenewDhcp();
+#else
+ UnixRenewDhcp();
+#endif
+}
+
+// Get a domain name for UNIX
+bool UnixGetDomainName(char *name, UINT size)
+{
+ bool ret = false;
+ BUF *b = ReadDump("/etc/resolv.conf");
+
+ if (b == NULL)
+ {
+ return false;
+ }
+
+ while (true)
+ {
+ char *s = CfgReadNextLine(b);
+ TOKEN_LIST *t;
+
+ if (s == NULL)
+ {
+ break;
+ }
+
+ Trim(s);
+
+ t = ParseToken(s, " \t");
+ if (t != NULL)
+ {
+ if (t->NumTokens == 2)
+ {
+ if (StrCmpi(t->Token[0], "domain") == 0)
+ {
+ StrCpy(name, size, t->Token[1]);
+ ret = true;
+ }
+ }
+ FreeToken(t);
+ }
+
+ Free(s);
+ }
+
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Get the domain name
+bool GetDomainName(char *name, UINT size)
+{
+ bool ret = false;
+ IP ip;
+ // Validate arguments
+ ClearStr(name, size);
+ if (name == NULL)
+ {
+ return false;
+ }
+
+#ifdef OS_WIN32
+ ClearStr(name, size);
+ ret = Win32GetDefaultDns(&ip, name, size);
+
+ if (ret == false || IsEmptyStr(name))
+ {
+ ret = Win32GetDnsSuffix(name, size);
+ }
+#else // OS_WIN32
+ ret = UnixGetDomainName(name, size);
+#endif // OS_WIN32
+
+ if (ret == false)
+ {
+ return false;
+ }
+
+ return (IsEmptyStr(name) ? false : true);
+}
+
+// Get the default DNS server
+bool GetDefaultDns(IP *ip)
+{
+ bool ret = false;
+#ifdef OS_WIN32
+ ret = Win32GetDefaultDns(ip, NULL, 0);
+#else
+ ret = UnixGetDefaultDns(ip);
+#endif // OS_WIN32
+ return ret;
+}
+
+// Creating a socket event
+SOCK_EVENT *NewSockEvent()
+{
+ SOCK_EVENT *e = NULL;
+#ifdef OS_WIN32
+ e = Win32NewSockEvent();
+#else
+ e = UnixNewSockEvent();
+#endif // OS_WIN32
+ return e;
+}
+
+// Set of the socket event
+void SetSockEvent(SOCK_EVENT *event)
+{
+#ifdef OS_WIN32
+ Win32SetSockEvent(event);
+#else
+ UnixSetSockEvent(event);
+#endif // OS_WIN32
+}
+
+// Clean-up of the socket event
+void CleanupSockEvent(SOCK_EVENT *event)
+{
+#ifdef OS_WIN32
+ Win32CleanupSockEvent(event);
+#else
+ UnixCleanupSockEvent(event);
+#endif // OS_WIN32
+}
+
+// Waiting for the socket event
+bool WaitSockEvent(SOCK_EVENT *event, UINT timeout)
+{
+ bool ret = false;
+#ifdef OS_WIN32
+ ret = Win32WaitSockEvent(event, timeout);
+#else
+ ret = UnixWaitSockEvent(event, timeout);
+#endif // OS_WIN32
+ return ret;
+}
+
+// Release of the socket event
+void ReleaseSockEvent(SOCK_EVENT *event)
+{
+ // Validate arguments
+ if (event == NULL)
+ {
+ return;
+ }
+
+ if (Release(event->ref) == 0)
+ {
+ CleanupSockEvent(event);
+ }
+}
+
+// Let belonging the socket to the socket event
+void JoinSockToSockEvent(SOCK *sock, SOCK_EVENT *event)
+{
+ // Validate arguments
+ if (sock == NULL || event == NULL)
+ {
+ return;
+ }
+
+ if (sock->Type == SOCK_INPROC)
+ {
+ // Set the SockEvent on the receiver TUBE for in-process type socket
+ SetTubeSockEvent(sock->RecvTube, event);
+ return;
+ }
+
+ if (sock->BulkRecvTube != NULL)
+ {
+ // Set the SockEvent on the receiver TUBE in case of R-UDP socket
+ SetTubeSockEvent(sock->BulkRecvTube, event);
+ }
+
+#ifdef OS_WIN32
+ Win32JoinSockToSockEvent(sock, event);
+#else
+ UnixJoinSockToSockEvent(sock, event);
+#endif // OS_WIN32
+}
+
+// New special cancel object
+CANCEL *NewCancelSpecial(void *hEvent)
+{
+ CANCEL *c;
+ // Validate arguments
+ if (hEvent == NULL)
+ {
+ return NULL;
+ }
+
+ c = ZeroMalloc(sizeof(CANCEL));
+ c->ref = NewRef();
+ c->SpecialFlag = true;
+
+#ifdef OS_WIN32
+ c->hEvent = (HANDLE)hEvent;
+#else // OS_WIN32
+ c->pipe_read = (int)hEvent;
+ c->pipe_write = -1;
+#endif // OS_WIN32
+
+ return c;
+}
+
+// Creating a cancel object
+CANCEL *NewCancel()
+{
+ CANCEL *c = NULL;
+#ifdef OS_WIN32
+ c = Win32NewCancel();
+#else
+ c = UnixNewCancel();
+#endif // OS_WIN32
+ return c;
+}
+
+// Release of the cancel object
+void ReleaseCancel(CANCEL *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ if (Release(c->ref) == 0)
+ {
+ CleanupCancel(c);
+ }
+}
+
+// Clean up of the cancel object
+void CleanupCancel(CANCEL *c)
+{
+#ifdef OS_WIN32
+ Win32CleanupCancel(c);
+#else
+ UnixCleanupCancel(c);
+#endif
+}
+
+// Cancellation triggered
+void Cancel(CANCEL *c)
+{
+#ifdef OS_WIN32
+ Win32Cancel(c);
+#else
+ UnixCancel(c);
+#endif
+}
+
+// Calculate the optimal route from the specified routing table
+ROUTE_ENTRY *GetBestRouteEntryFromRouteTable(ROUTE_TABLE *table, IP *ip)
+{
+ return GetBestRouteEntryFromRouteTableEx(table, ip, 0);
+}
+ROUTE_ENTRY *GetBestRouteEntryFromRouteTableEx(ROUTE_TABLE *table, IP *ip, UINT exclude_if_id)
+{
+ UINT i;
+ ROUTE_ENTRY *ret = NULL;
+ ROUTE_ENTRY *tmp = NULL;
+ UINT64 min_score = 0;
+ // Validate arguments
+ if (ip == NULL || table == NULL)
+ {
+ return NULL;
+ }
+
+ if (IsIP6(ip))
+ {
+ // IPv6 is not supported
+ return NULL;
+ }
+
+ // Select routing table entry by following rule
+ // 1. Largest subnet mask
+ // 2. Smallest metric value
+ for (i = 0;i < table->NumEntry;i++)
+ {
+ ROUTE_ENTRY *e = table->Entry[i];
+ UINT dest, net, mask;
+
+ dest = IPToUINT(ip);
+ net = IPToUINT(&e->DestIP);
+ mask = IPToUINT(&e->DestMask);
+
+ if (exclude_if_id != 0)
+ {
+ if (e->InterfaceID == exclude_if_id)
+ {
+ continue;
+ }
+ }
+
+ // Mask test
+ if ((dest & mask) == (net & mask))
+ {
+ // Calculate the score
+ UINT score_high32 = mask;
+ UINT score_low32 = 0xFFFFFFFF - e->Metric;
+ UINT64 score64 = (UINT64)score_high32 * (UINT64)0x80000000 * (UINT64)2 + (UINT64)score_low32;
+ if (score64 == 0)
+ {
+ score64 = 1;
+ }
+
+ e->InnerScore = score64;
+ }
+ }
+
+ tmp = NULL;
+
+ // Search for the item with maximum score
+ for (i = 0;i < table->NumEntry;i++)
+ {
+ ROUTE_ENTRY *e = table->Entry[i];
+
+ if (e->InnerScore != 0)
+ {
+ if (e->InnerScore >= min_score)
+ {
+ tmp = e;
+ min_score = e->InnerScore;
+ }
+ }
+ }
+
+ if (tmp != NULL)
+ {
+ UINT dest, gateway, mask;
+
+ // Generate an entry
+ ret = ZeroMallocFast(sizeof(ROUTE_ENTRY));
+
+ Copy(&ret->DestIP, ip, sizeof(IP));
+ ret->DestMask.addr[0] = 255;
+ ret->DestMask.addr[1] = 255;
+ ret->DestMask.addr[2] = 255;
+ ret->DestMask.addr[3] = 255;
+ Copy(&ret->GatewayIP, &tmp->GatewayIP, sizeof(IP));
+ ret->InterfaceID = tmp->InterfaceID;
+ ret->LocalRouting = tmp->LocalRouting;
+ ret->OldIfMetric = tmp->Metric;
+ ret->Metric = 1;
+ ret->PPPConnection = tmp->PPPConnection;
+
+ // Calculation related to routing control
+ dest = IPToUINT(&tmp->DestIP);
+ gateway = IPToUINT(&tmp->GatewayIP);
+ mask = IPToUINT(&tmp->DestMask);
+ if ((dest & mask) == (gateway & mask))
+ {
+#ifdef OS_WIN32
+ if (MsIsVista() == false)
+ {
+ // Adjust for Windows
+ ret->PPPConnection = true;
+ }
+#endif // OS_WIN32
+ }
+ }
+
+ return ret;
+}
+
+// Release the routing entry
+void FreeRouteEntry(ROUTE_ENTRY *e)
+{
+ // Validate arguments
+ if (e == NULL)
+ {
+ return;
+ }
+
+ Free(e);
+}
+
+// Get the best route entry by analyzing the current routing table
+ROUTE_ENTRY *GetBestRouteEntry(IP *ip)
+{
+ return GetBestRouteEntryEx(ip, 0);
+}
+ROUTE_ENTRY *GetBestRouteEntryEx(IP *ip, UINT exclude_if_id)
+{
+ ROUTE_TABLE *table;
+ ROUTE_ENTRY *e = NULL;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return NULL;
+ }
+
+ table = GetRouteTable();
+ if (table == NULL)
+ {
+ return NULL;
+ }
+
+ e = GetBestRouteEntryFromRouteTableEx(table, ip, exclude_if_id);
+ FreeRouteTable(table);
+
+ return e;
+}
+
+// Get the interface ID of the virtual LAN card
+UINT GetVLanInterfaceID(char *tag_name)
+{
+ UINT ret = 0;
+#ifdef OS_WIN32
+ ret = Win32GetVLanInterfaceID(tag_name);
+#else // OS_WIN32
+ ret = UnixGetVLanInterfaceID(tag_name);
+#endif // OS_WIN32
+ return ret;
+}
+
+// Release of enumeration variable of virtual LAN card
+void FreeEnumVLan(char **s)
+{
+ char *a;
+ UINT i;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+ i = 0;
+ while (true)
+ {
+ a = s[i++];
+ if (a == NULL)
+ {
+ break;
+ }
+ Free(a);
+ }
+
+ Free(s);
+}
+
+// Enumeration of virtual LAN cards
+char **EnumVLan(char *tag_name)
+{
+ char **ret = NULL;
+#ifdef OS_WIN32
+ ret = Win32EnumVLan(tag_name);
+#else // OS_WIN32
+ ret = UnixEnumVLan(tag_name);
+#endif // OS_WIN32
+ return ret;
+}
+
+// Display the routing table
+void DebugPrintRouteTable(ROUTE_TABLE *r)
+{
+ UINT i;
+ // Validate arguments
+ if (r == NULL)
+ {
+ return;
+ }
+
+ if (IsDebug() == false)
+ {
+ return;
+ }
+
+ Debug("---- Routing Table (%u Entries) ----\n", r->NumEntry);
+
+ for (i = 0;i < r->NumEntry;i++)
+ {
+ Debug(" ");
+
+ DebugPrintRoute(r->Entry[i]);
+ }
+
+ Debug("------------------------------------\n");
+}
+
+// Display the routing table entry
+void DebugPrintRoute(ROUTE_ENTRY *e)
+{
+ char tmp[MAX_SIZE];
+ // Validate arguments
+ if (e == NULL)
+ {
+ return;
+ }
+
+ if (IsDebug() == false)
+ {
+ return;
+ }
+
+ RouteToStr(tmp, sizeof(tmp), e);
+
+ Debug("%s\n", tmp);
+}
+
+// Convert the routing table entry to string
+void RouteToStr(char *str, UINT str_size, ROUTE_ENTRY *e)
+{
+ char dest_ip[MAX_PATH];
+ char dest_mask[MAX_PATH];
+ char gateway_ip[MAX_PATH];
+ // Validate arguments
+ if (str == NULL || e == NULL)
+ {
+ return;
+ }
+
+ IPToStr(dest_ip, sizeof(dest_ip), &e->DestIP);
+ IPToStr(dest_mask, sizeof(dest_mask), &e->DestMask);
+ 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);
+}
+
+// Delete the routing table
+void DeleteRouteEntry(ROUTE_ENTRY *e)
+{
+ Debug("DeleteRouteEntry();\n");
+#ifdef OS_WIN32
+ Win32DeleteRouteEntry(e);
+#else // OS_WIN32
+ UnixDeleteRouteEntry(e);
+#endif
+}
+
+// Add to the routing table
+bool AddRouteEntry(ROUTE_ENTRY *e)
+{
+ bool dummy = false;
+ return AddRouteEntryEx(e, &dummy);
+}
+bool AddRouteEntryEx(ROUTE_ENTRY *e, bool *already_exists)
+{
+ bool ret = false;
+ Debug("AddRouteEntryEx();\n");
+#ifdef OS_WIN32
+ ret = Win32AddRouteEntry(e, already_exists);
+#else // OS_WIN32
+ ret = UnixAddRouteEntry(e, already_exists);
+#endif
+ return ret;
+}
+
+// Get the routing table
+ROUTE_TABLE *GetRouteTable()
+{
+ ROUTE_TABLE *t = NULL;
+ UINT i;
+ BUF *buf = NewBuf();
+ UCHAR hash[MD5_SIZE];
+
+#ifdef OS_WIN32
+ t = Win32GetRouteTable();
+#else //OS_WIN32
+ t = UnixGetRouteTable();
+#endif // OS_WIN32
+
+ WriteBuf(buf, &t->NumEntry, sizeof(t->NumEntry));
+
+ for (i = 0;i < t->NumEntry;i++)
+ {
+ ROUTE_ENTRY *e = t->Entry[i];
+
+ WriteBuf(buf, e, sizeof(ROUTE_ENTRY));
+ }
+
+ Hash(hash, buf->Buf, buf->Size, false);
+
+ FreeBuf(buf);
+
+ Copy(&t->HashedValue, hash, sizeof(t->HashedValue));
+
+ return t;
+}
+
+// Release of the routing table
+void FreeRouteTable(ROUTE_TABLE *t)
+{
+ UINT i;
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < t->NumEntry;i++)
+ {
+ Free(t->Entry[i]);
+ }
+ Free(t->Entry);
+ Free(t);
+}
+
+// UDP receiving
+UINT RecvFrom(SOCK *sock, IP *src_addr, UINT *src_port, void *data, UINT size)
+{
+ SOCKET s;
+ int ret, sz;
+ struct sockaddr_in addr;
+ // Validate arguments
+ if (sock != NULL)
+ {
+ sock->IgnoreRecvErr = false;
+ }
+ if (sock == NULL || src_addr == NULL || src_port == NULL || data == NULL)
+ {
+ return false;
+ }
+ if (sock->Type != SOCK_UDP || sock->socket == INVALID_SOCKET)
+ {
+ return false;
+ }
+ if (size == 0)
+ {
+ return false;
+ }
+
+ if (sock->IPv6)
+ {
+ return RecvFrom6(sock, src_addr, src_port, data, size);
+ }
+
+ s = sock->socket;
+
+ sz = sizeof(addr);
+ ret = recvfrom(s, data, size, 0, (struct sockaddr *)&addr, (int *)&sz);
+ if (ret > 0)
+ {
+ InAddrToIP(src_addr, &addr.sin_addr);
+ *src_port = (UINT)ntohs(addr.sin_port);
+ if (sock->IsRawSocket)
+ {
+ *src_port = sock->LocalPort;
+/*
+ {
+ char tmp[MAX_SIZE];
+
+ IPToStr(tmp, sizeof(tmp), &sock->LocalIP);
+ Debug("Raw: %u from %s\n", sock->LocalPort, tmp);
+ }*/
+ }
+
+ Lock(sock->lock);
+ {
+ sock->RecvNum++;
+ sock->RecvSize += (UINT64)ret;
+ }
+ Unlock(sock->lock);
+
+ // Debug("UDP RecvFrom: %u\n", ret);
+
+ return (UINT)ret;
+ }
+ else
+ {
+ sock->IgnoreRecvErr = false;
+
+#ifdef OS_WIN32
+ if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH ||
+ WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS)
+ {
+ sock->IgnoreRecvErr = true;
+ }
+ else if (WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINPROGRESS)
+ {
+ return SOCK_LATER;
+ }
+ else
+ {
+ UINT e = WSAGetLastError();
+// Debug("RecvFrom Error: %u\n", e);
+ }
+#else // OS_WIN32
+ if (errno == ECONNREFUSED || errno == ECONNRESET || errno == EMSGSIZE || errno == ENOBUFS || errno == ENOMEM || errno == EINTR)
+ {
+ sock->IgnoreRecvErr = true;
+ }
+ else if (errno == EAGAIN)
+ {
+ return SOCK_LATER;
+ }
+#endif // OS_WIN32
+ return 0;
+ }
+}
+UINT RecvFrom6(SOCK *sock, IP *src_addr, UINT *src_port, void *data, UINT size)
+{
+ SOCKET s;
+ int ret, sz;
+ struct sockaddr_in6 addr;
+ // Validate arguments
+ if (sock != NULL)
+ {
+ sock->IgnoreRecvErr = false;
+ }
+ if (sock == NULL || src_addr == NULL || src_port == NULL || data == NULL)
+ {
+ return false;
+ }
+ if (sock->Type != SOCK_UDP || sock->socket == INVALID_SOCKET)
+ {
+ return false;
+ }
+ if (size == 0)
+ {
+ return false;
+ }
+
+ s = sock->socket;
+
+ sz = sizeof(addr);
+ ret = recvfrom(s, data, size, 0, (struct sockaddr *)&addr, (int *)&sz);
+ if (ret > 0)
+ {
+ InAddrToIP6(src_addr, &addr.sin6_addr);
+ src_addr->ipv6_scope_id = addr.sin6_scope_id;
+ *src_port = (UINT)ntohs(addr.sin6_port);
+ if (sock->IsRawSocket)
+ {
+ *src_port = sock->LocalPort;
+ }
+
+ Lock(sock->lock);
+ {
+ sock->RecvNum++;
+ sock->RecvSize += (UINT64)ret;
+ }
+ Unlock(sock->lock);
+
+ // Debug("UDP RecvFrom: %u\n", ret);
+
+ return (UINT)ret;
+ }
+ else
+ {
+ sock->IgnoreRecvErr = false;
+
+#ifdef OS_WIN32
+ if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH ||
+ WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS)
+ {
+ sock->IgnoreRecvErr = true;
+ }
+ else if (WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINPROGRESS)
+ {
+ return SOCK_LATER;
+ }
+ else
+ {
+ UINT e = WSAGetLastError();
+ // Debug("RecvFrom Error: %u\n", e);
+ }
+#else // OS_WIN32
+ if (errno == ECONNREFUSED || errno == ECONNRESET || errno == EMSGSIZE || errno == ENOBUFS || errno == ENOMEM || errno == EINTR)
+ {
+ sock->IgnoreRecvErr = true;
+ }
+ else if (errno == EAGAIN)
+ {
+ return SOCK_LATER;
+ }
+#endif // OS_WIN32
+ return 0;
+ }
+}
+
+// Lock the OpenSSL
+void LockOpenSSL()
+{
+ Lock(openssl_lock);
+}
+
+// Unlock the OpenSSL
+void UnlockOpenSSL()
+{
+ Unlock(openssl_lock);
+}
+
+// UDP transmission
+UINT SendTo(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size)
+{
+ return SendToEx(sock, dest_addr, dest_port, data, size, false);
+}
+UINT SendToEx(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size, bool broadcast)
+{
+ SOCKET s;
+ int ret;
+ struct sockaddr_in addr;
+ // Validate arguments
+ if (sock != NULL)
+ {
+ sock->IgnoreSendErr = false;
+ }
+ if (sock == NULL || dest_addr == NULL || (sock->IsRawSocket == false && dest_port == 0) || data == NULL)
+ {
+ return 0;
+ }
+ if (dest_port >= 65536 && sock->IsRawSocket == false)
+ {
+ return 0;
+ }
+ if (sock->Type != SOCK_UDP || sock->socket == INVALID_SOCKET)
+ {
+ return 0;
+ }
+ if (size == 0)
+ {
+ return 0;
+ }
+
+ if (sock->IPv6)
+ {
+ return SendTo6Ex(sock, dest_addr, dest_port, data, size, broadcast);
+ }
+
+ if (IsIP4(dest_addr) == false)
+ {
+ return 0;
+ }
+
+ s = sock->socket;
+ Zero(&addr, sizeof(addr));
+ addr.sin_family = AF_INET;
+ if (sock->IsRawSocket == false)
+ {
+ addr.sin_port = htons((USHORT)dest_port);
+ }
+ 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 (sock->UdpBroadcast == false)
+ {
+ bool yes = true;
+
+ sock->UdpBroadcast = true;
+
+ setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *)&yes, sizeof(yes));
+ }
+ }
+
+ ret = sendto(s, data, size, 0, (struct sockaddr *)&addr, sizeof(addr));
+ if (ret != (int)size)
+ {
+ sock->IgnoreSendErr = false;
+
+#ifdef OS_WIN32
+ if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH ||
+ WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEINVAL)
+ {
+ sock->IgnoreSendErr = true;
+ }
+ else if (WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINPROGRESS)
+ {
+ return SOCK_LATER;
+ }
+ else
+ {
+ UINT e = WSAGetLastError();
+ Debug("SendTo Error; %u\n", e);
+ }
+#else // OS_WIN32
+ if (errno == ECONNREFUSED || errno == ECONNRESET || errno == EMSGSIZE || errno == ENOBUFS || errno == ENOMEM || errno == EINTR)
+ {
+ sock->IgnoreSendErr = true;
+ }
+ else if (errno == EAGAIN)
+ {
+ return SOCK_LATER;
+ }
+#endif // OS_WIN32
+ return 0;
+ }
+
+ Lock(sock->lock);
+ {
+ sock->SendSize += (UINT64)size;
+ sock->SendNum++;
+ }
+ Unlock(sock->lock);
+
+ return ret;
+}
+UINT SendTo6(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size)
+{
+ return SendTo6Ex(sock, dest_addr, dest_port, data, size, false);
+}
+UINT SendTo6Ex(SOCK *sock, IP *dest_addr, UINT dest_port, void *data, UINT size, bool broadcast)
+{
+ SOCKET s;
+ int ret;
+ struct sockaddr_in6 addr;
+ UINT type;
+ // Validate arguments
+ if (sock != NULL)
+ {
+ sock->IgnoreSendErr = false;
+ }
+ if (sock == NULL || dest_addr == NULL || (sock->IsRawSocket == false && dest_port == 0) || data == NULL)
+ {
+ return 0;
+ }
+ if (dest_port >= 65536 && sock->IsRawSocket == false)
+ {
+ return 0;
+ }
+ if (sock->Type != SOCK_UDP || sock->socket == INVALID_SOCKET)
+ {
+ return 0;
+ }
+ if (size == 0)
+ {
+ return 0;
+ }
+
+ if (IsIP6(dest_addr) == false)
+ {
+ return 0;
+ }
+
+ s = sock->socket;
+ Zero(&addr, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ if (sock->IsRawSocket == false)
+ {
+ addr.sin6_port = htons((USHORT)dest_port);
+ }
+ IPToInAddr6(&addr.sin6_addr, dest_addr);
+ addr.sin6_scope_id = dest_addr->ipv6_scope_id;
+
+ type = GetIPAddrType6(dest_addr);
+
+ if ((type & IPV6_ADDR_MULTICAST) || broadcast)
+ {
+ if (sock->UdpBroadcast == false)
+ {
+ bool yes = true;
+
+ sock->UdpBroadcast = true;
+
+ setsockopt(s, SOL_SOCKET, SO_BROADCAST, (char *)&yes, sizeof(yes));
+ }
+ }
+
+ ret = sendto(s, data, size, 0, (struct sockaddr *)&addr, sizeof(addr));
+ if (ret != (int)size)
+ {
+ sock->IgnoreSendErr = false;
+
+#ifdef OS_WIN32
+ if (WSAGetLastError() == WSAECONNRESET || WSAGetLastError() == WSAEMSGSIZE || WSAGetLastError() == WSAENETUNREACH ||
+ WSAGetLastError() == WSAENOBUFS || WSAGetLastError() == WSAEHOSTUNREACH || WSAGetLastError() == WSAEUSERS || WSAGetLastError() == WSAEINVAL)
+ {
+ sock->IgnoreSendErr = true;
+ }
+ else if (WSAGetLastError() == WSAEWOULDBLOCK || WSAGetLastError() == WSAEINPROGRESS)
+ {
+ return SOCK_LATER;
+ }
+ else
+ {
+ UINT e = WSAGetLastError();
+ }
+#else // OS_WIN32
+ if (errno == ECONNREFUSED || errno == ECONNRESET || errno == EMSGSIZE || errno == ENOBUFS || errno == ENOMEM || errno == EINTR)
+ {
+ sock->IgnoreSendErr = true;
+ }
+ else if (errno == EAGAIN)
+ {
+ return SOCK_LATER;
+ }
+#endif // OS_WIN32
+ return 0;
+ }
+
+ Lock(sock->lock);
+ {
+ sock->SendSize += (UINT64)size;
+ sock->SendNum++;
+ }
+ Unlock(sock->lock);
+
+ return ret;
+}
+
+// Disable the UDP checksum
+void DisableUDPChecksum(SOCK *s)
+{
+ bool true_flag = true;
+ // Validate arguments
+ if (s == NULL || s->Type != SOCK_UDP)
+ {
+ return;
+ }
+
+ if (s->socket != INVALID_SOCKET)
+ {
+ if (s->IPv6 == false)
+ {
+#ifdef UDP_NOCHECKSUM
+ setsockopt(s->socket, IPPROTO_UDP, UDP_NOCHECKSUM, (char *)&true_flag, sizeof(bool));
+#endif // UDP_NOCHECKSUM
+ }
+ }
+}
+
+// Set the socket to asynchronous mode
+void InitAsyncSocket(SOCK *sock)
+{
+#ifdef OS_WIN32
+ Win32InitAsyncSocket(sock);
+#else // OS_WIN32
+ UnixInitAsyncSocket(sock);
+#endif // OS_WIN32
+}
+
+// Open a UDP port (port number is random, but determine the randomness in the seed)
+SOCK *NewUDPEx2Rand(bool ipv6, IP *ip, void *rand_seed, UINT rand_seed_size, UINT num_retry)
+{
+ UINT i;
+ // Validate arguments
+ if (rand_seed == NULL || rand_seed_size == 0)
+ {
+ return NULL;
+ }
+ if (num_retry == 0)
+ {
+ num_retry = RAND_UDP_PORT_DEFAULT_NUM_RETRY;
+ }
+
+ for (i = 0; i < (num_retry + 1);i++)
+ {
+ BUF *buf = NewBuf();
+ UCHAR hash[SHA1_SIZE];
+ UINT port = 0;
+ SOCK *s;
+
+ WriteBuf(buf, rand_seed, rand_seed_size);
+ WriteBufInt(buf, i);
+
+ HashSha1(hash, buf->Buf, buf->Size);
+
+ FreeBuf(buf);
+
+ port = READ_UINT(hash);
+
+ port = RAND_UDP_PORT_START + (port % (RAND_UDP_PORT_END - RAND_UDP_PORT_START));
+
+ s = NewUDPEx2(port, ipv6, ip);
+
+ if (s != NULL)
+ {
+ return s;
+ }
+ }
+
+ return NewUDPEx2(0, ipv6, ip);
+}
+
+// Generate a random port number (based on the EXE path and machine key)
+UINT NewRandPortByMachineAndExePath(UINT start_port, UINT end_port, UINT additional_int)
+{
+ BUF *b;
+ char machine_name[MAX_SIZE];
+ wchar_t exe_path[MAX_PATH];
+ char *product_id = NULL;
+ UCHAR hash[SHA1_SIZE];
+
+#ifdef OS_WIN32
+ product_id = MsRegReadStr(REG_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductId");
+ if (product_id == NULL)
+ {
+ product_id = MsRegReadStr(REG_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", "ProductId");
+ }
+#endif // OS_WIN32
+
+ b = NewBuf();
+
+ GetMachineHostName(machine_name, sizeof(machine_name));
+ Trim(machine_name);
+ StrUpper(machine_name);
+
+ GetExeNameW(exe_path, sizeof(exe_path));
+ UniTrim(exe_path);
+ UniStrUpper(exe_path);
+
+ WriteBuf(b, machine_name, StrSize(machine_name));
+ WriteBuf(b, exe_path, UniStrSize(exe_path));
+ WriteBuf(b, product_id, StrSize(product_id));
+ WriteBufInt(b, additional_int);
+
+ HashSha1(hash, b->Buf, b->Size);
+
+ FreeBuf(b);
+
+ Free(product_id);
+
+ return (READ_UINT(hash) % (end_port - start_port)) + start_port;
+}
+
+// Open the UDP port (based on the EXE path and machine key)
+SOCK *NewUDPEx2RandMachineAndExePath(bool ipv6, IP *ip, UINT num_retry, UCHAR rand_port_id)
+{
+ BUF *b;
+ char machine_name[MAX_SIZE];
+ wchar_t exe_path[MAX_PATH];
+ char *product_id = NULL;
+ UCHAR hash[SHA1_SIZE];
+
+#ifdef OS_WIN32
+ product_id = MsRegReadStr(REG_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion", "ProductId");
+ if (product_id == NULL)
+ {
+ product_id = MsRegReadStr(REG_LOCAL_MACHINE, "SOFTWARE\\Microsoft\\Windows\\CurrentVersion", "ProductId");
+ }
+#endif // OS_WIN32
+
+ b = NewBuf();
+
+ GetMachineHostName(machine_name, sizeof(machine_name));
+ Trim(machine_name);
+ StrUpper(machine_name);
+
+ GetExeNameW(exe_path, sizeof(exe_path));
+ UniTrim(exe_path);
+ UniStrUpper(exe_path);
+
+ WriteBuf(b, machine_name, StrSize(machine_name));
+ WriteBuf(b, exe_path, UniStrSize(exe_path));
+ WriteBuf(b, product_id, StrSize(product_id));
+ WriteBufChar(b, rand_port_id);
+ //WriteBufInt(b, GetHostIPAddressHash32());
+
+ HashSha1(hash, b->Buf, b->Size);
+
+ FreeBuf(b);
+
+ Free(product_id);
+
+ return NewUDPEx2Rand(ipv6, ip, hash, sizeof(hash), num_retry);
+}
+
+// Create and initialize the UDP socket
+// If port is specified as 0, system assigns a certain port.
+SOCK *NewUDP(UINT port)
+{
+ return NewUDPEx(port, false);
+}
+SOCK *NewUDPEx(UINT port, bool ipv6)
+{
+ return NewUDPEx2(port, ipv6, NULL);
+}
+SOCK *NewUDPEx2(UINT port, bool ipv6, IP *ip)
+{
+ if (ipv6 == false)
+ {
+ return NewUDP4(port, ip);
+ }
+ else
+ {
+ return NewUDP6(port, ip);
+ }
+}
+SOCK *NewUDPEx3(UINT port, IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return NewUDPEx2(port, false, NULL);
+ }
+
+ if (IsIP4(ip))
+ {
+ return NewUDPEx2(port, false, ip);
+ }
+ else
+ {
+ return NewUDPEx2(port, true, ip);
+ }
+}
+SOCK *NewUDP4(UINT port, IP *ip)
+{
+ SOCK *sock;
+ SOCKET s;
+ struct sockaddr_in addr;
+ // Validate arguments
+ if (ip != NULL && IsIP4(ip) == false)
+ {
+ return NULL;
+ }
+
+ if (IS_SPECIAL_PORT(port) == false)
+ {
+ s = socket(AF_INET, SOCK_DGRAM, IPPROTO_UDP);
+ }
+ else
+ {
+ s = socket(AF_INET, SOCK_RAW, GET_SPECIAL_PORT(port));
+ }
+ if (s == INVALID_SOCKET)
+ {
+ return NULL;
+ }
+
+ Zero(&addr, sizeof(addr));
+ addr.sin_family = AF_INET;
+
+ if (ip == NULL || IsZeroIP(ip))
+ {
+ addr.sin_addr.s_addr = htonl(INADDR_ANY);
+ }
+ else
+ {
+ IPToInAddr(&addr.sin_addr, ip);
+ }
+
+ if (port == 0 || IS_SPECIAL_PORT(port))
+ {
+ addr.sin_port = 0;
+ }
+ else
+ {
+ addr.sin_port = htons((USHORT)port);
+ }
+
+ if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+ {
+ // Failure
+ if (port != 0)
+ {
+ bool true_flag = true;
+ setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&true_flag, sizeof(bool));
+ if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+ {
+ bool false_flag = false;
+ setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&false_flag, sizeof(bool));
+#ifdef SO_EXCLUSIVEADDRUSE
+ setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *)&true_flag, sizeof(bool));
+#endif // SO_EXCLUSIVEADDRUSE
+ if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+ {
+ closesocket(s);
+ return NULL;
+ }
+ }
+ }
+ else
+ {
+ closesocket(s);
+ return NULL;
+ }
+ }
+
+ sock = NewSock();
+
+ sock->Type = SOCK_UDP;
+ sock->Connected = false;
+ sock->AsyncMode = false;
+ sock->ServerMode = false;
+ if (port != 0)
+ {
+ sock->ServerMode = true;
+ }
+
+ sock->socket = s;
+
+ InitUdpSocketBufferSize((int)s);
+
+ if (IS_SPECIAL_PORT(port))
+ {
+ bool no = false;
+ setsockopt(sock->socket, IPPROTO_IP, IP_HDRINCL, (char *)&no, sizeof(no));
+
+ sock->IsRawSocket = true;
+ sock->RawSocketIPProtocol = GET_SPECIAL_PORT(port);
+ }
+
+ QuerySocketInformation(sock);
+
+ return sock;
+}
+SOCK *NewUDP6(UINT port, IP *ip)
+{
+ SOCK *sock;
+ SOCKET s;
+ struct sockaddr_in6 addr;
+ // Validate arguments
+ if (ip != NULL && IsIP6(ip) == false)
+ {
+ return NULL;
+ }
+
+ if (IS_SPECIAL_PORT(port) == false)
+ {
+ s = socket(AF_INET6, SOCK_DGRAM, IPPROTO_UDP);
+ }
+ else
+ {
+ s = socket(AF_INET6, SOCK_RAW, GET_SPECIAL_PORT(port));
+ }
+ if (s == INVALID_SOCKET)
+ {
+ return NULL;
+ }
+
+ Zero(&addr, sizeof(addr));
+ addr.sin6_family = AF_INET6;
+ if (port == 0)
+ {
+ addr.sin6_port = 0;
+ }
+ else
+ {
+ addr.sin6_port = htons((USHORT)port);
+ }
+
+ if (ip != NULL && IsZeroIP(ip) == false)
+ {
+ IPToInAddr6(&addr.sin6_addr, ip);
+ addr.sin6_scope_id = ip->ipv6_scope_id;
+ }
+
+ if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+ {
+ // Failure
+ if (port != 0)
+ {
+ bool true_flag = true;
+ setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&true_flag, sizeof(bool));
+ if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+ {
+ bool false_flag = false;
+ setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&false_flag, sizeof(bool));
+#ifdef SO_EXCLUSIVEADDRUSE
+ setsockopt(s, SOL_SOCKET, SO_EXCLUSIVEADDRUSE, (char *)&true_flag, sizeof(bool));
+#endif // SO_EXCLUSIVEADDRUSE
+ if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) != 0)
+ {
+ closesocket(s);
+ return NULL;
+ }
+ }
+ }
+ else
+ {
+ closesocket(s);
+ return NULL;
+ }
+ }
+
+ sock = NewSock();
+
+ sock->Type = SOCK_UDP;
+ sock->Connected = false;
+ sock->AsyncMode = false;
+ sock->ServerMode = false;
+ sock->IPv6 = true;
+ if (port != 0)
+ {
+ sock->ServerMode = true;
+ }
+
+ sock->socket = s;
+
+ InitUdpSocketBufferSize(s);
+
+ if (IS_SPECIAL_PORT(port))
+ {
+ bool no = false;
+#ifdef IPV6_HDRINCL
+ setsockopt(sock->socket, IPPROTO_IP, IPV6_HDRINCL, (char *)&no, sizeof(no));
+#endif // IPV6_HDRINCL
+ setsockopt(sock->socket, IPPROTO_IP, IP_HDRINCL, (char *)&no, sizeof(no));
+
+ sock->IsRawSocket = true;
+ sock->RawSocketIPProtocol = GET_SPECIAL_PORT(port);
+ }
+
+ QuerySocketInformation(sock);
+
+ return sock;
+}
+
+// Select function
+void Select(SOCKSET *set, UINT timeout, CANCEL *c1, CANCEL *c2)
+{
+#ifdef OS_WIN32
+ Win32Select(set, timeout, c1, c2);
+#else
+ UnixSelect(set, timeout, c1, c2);
+#endif // OS_WIN32
+}
+
+// Add a socket to the socket set
+void AddSockSet(SOCKSET *set, SOCK *sock)
+{
+ // Validate arguments
+ if (set == NULL || sock == NULL)
+ {
+ return;
+ }
+ if (sock->Type == SOCK_TCP && sock->Connected == false)
+ {
+ return;
+ }
+
+ if (set->NumSocket >= MAX_SOCKSET_NUM)
+ {
+ // Upper limit
+ return;
+ }
+ set->Sock[set->NumSocket++] = sock;
+}
+
+// Initializing the socket set
+void InitSockSet(SOCKSET *set)
+{
+ // Validate arguments
+ if (set == NULL)
+ {
+ return;
+ }
+
+ Zero(set, sizeof(SOCKSET));
+}
+
+// Receive all by TCP
+bool RecvAll(SOCK *sock, void *data, UINT size, bool secure)
+{
+ UINT recv_size, sz, ret;
+ // Validate arguments
+ if (sock == NULL || data == NULL)
+ {
+ return false;
+ }
+ if (size == 0)
+ {
+ return true;
+ }
+ if (sock->AsyncMode)
+ {
+ return false;
+ }
+
+ recv_size = 0;
+
+ while (true)
+ {
+ sz = size - recv_size;
+ ret = Recv(sock, (UCHAR *)data + recv_size, sz, secure);
+ if (ret == 0)
+ {
+ return false;
+ }
+ recv_size += ret;
+ if (recv_size >= size)
+ {
+ return true;
+ }
+ }
+}
+
+// Send the TCP send buffer
+bool SendNow(SOCK *sock, int secure)
+{
+ bool ret;
+ // Validate arguments
+ if (sock == NULL || sock->AsyncMode != false)
+ {
+ return false;
+ }
+ if (sock->SendBuf->Size == 0)
+ {
+ return true;
+ }
+
+ ret = SendAll(sock, sock->SendBuf->Buf, sock->SendBuf->Size, secure);
+ ClearBuf(sock->SendBuf);
+
+ return ret;
+}
+
+// Append to the TCP send buffer
+void SendAdd(SOCK *sock, void *data, UINT size)
+{
+ // Validate arguments
+ if (sock == NULL || data == NULL || size == 0 || sock->AsyncMode != false)
+ {
+ return;
+ }
+
+ WriteBuf(sock->SendBuf, data, size);
+}
+
+// Send all by TCP
+bool SendAll(SOCK *sock, void *data, UINT size, bool secure)
+{
+ UCHAR *buf;
+ UINT sent_size;
+ UINT ret;
+ // Validate arguments
+ if (sock == NULL || data == NULL)
+ {
+ return false;
+ }
+ if (sock->AsyncMode)
+ {
+ return false;
+ }
+ if (size == 0)
+ {
+ return true;
+ }
+
+ buf = (UCHAR *)data;
+ sent_size = 0;
+
+ while (true)
+ {
+ ret = Send(sock, buf, size - sent_size, secure);
+ if (ret == 0)
+ {
+ return false;
+ }
+ sent_size += ret;
+ buf += ret;
+ if (sent_size >= size)
+ {
+ return true;
+ }
+ }
+}
+
+// Set the cipher algorithm name to want to use
+void SetWantToUseCipher(SOCK *sock, char *name)
+{
+ // Validate arguments
+ if (sock == NULL || name == NULL)
+ {
+ return;
+ }
+
+ if (sock->WaitToUseCipher)
+ {
+ Free(sock->WaitToUseCipher);
+ }
+ sock->WaitToUseCipher = CopyStr(name);
+}
+
+// Add all the chain certificates in the chain_certs directory
+void AddChainSslCertOnDirectory(struct ssl_ctx_st *ctx)
+{
+ wchar_t dirname[MAX_SIZE];
+ wchar_t exedir[MAX_SIZE];
+ DIRLIST *dir;
+
+ // Validate arguments
+ if (ctx == NULL)
+ {
+ return;
+ }
+
+ GetExeDirW(exedir, sizeof(exedir));
+
+ CombinePathW(dirname, sizeof(dirname), exedir, L"chain_certs");
+
+ MakeDirExW(dirname);
+
+ dir = EnumDirW(dirname);
+
+ if (dir != NULL)
+ {
+ UINT i;
+
+ for (i = 0;i < dir->NumFiles;i++)
+ {
+ DIRENT *e = dir->File[i];
+
+ if (e->Folder == false)
+ {
+ wchar_t tmp[MAX_SIZE];
+ X *x;
+
+ CombinePathW(tmp, sizeof(tmp), dirname, e->FileNameW);
+
+ x = FileToXW(tmp);
+
+ if (x != NULL)
+ {
+ AddChainSslCert(ctx, x);
+
+ FreeX(x);
+ }
+ }
+ }
+
+ FreeDir(dir);
+ }
+}
+
+// Add the chain certificate
+bool AddChainSslCert(struct ssl_ctx_st *ctx, X *x)
+{
+ bool ret = false;
+ X *x_copy;
+ // Validate arguments
+ if (ctx == NULL || x == NULL)
+ {
+ return ret;
+ }
+
+ x_copy = CloneX(x);
+
+ if (x_copy != NULL)
+ {
+ SSL_CTX_add_extra_chain_cert(ctx, x_copy->x509);
+ x_copy->do_not_free = true;
+
+ ret = true;
+
+ FreeX(x_copy);
+ }
+
+ return ret;
+}
+
+// Start a TCP-SSL communication
+bool StartSSL(SOCK *sock, X *x, K *priv)
+{
+ return StartSSLEx(sock, x, priv, false, 0, NULL);
+}
+bool StartSSLEx(SOCK *sock, X *x, K *priv, bool client_tls, UINT ssl_timeout, char *sni_hostname)
+{
+ X509 *x509;
+ EVP_PKEY *key;
+ UINT prev_timeout = 1024;
+ SSL_CTX *ssl_ctx;
+
+#ifdef UNIX_SOLARIS
+ SOCKET_TIMEOUT_PARAM *ttparam;
+#endif //UNIX_SOLARIS
+
+ // Validate arguments
+ if (sock == NULL)
+ {
+ Debug("StartSSL Error: #0\n");
+ return false;
+ }
+ if (sock->Connected && sock->Type == SOCK_INPROC && sock->ListenMode == false)
+ {
+ sock->SecureMode = true;
+ return true;
+ }
+ if (sock->Connected == false || sock->socket == INVALID_SOCKET ||
+ sock->ListenMode != false)
+ {
+ Debug("StartSSL Error: #1\n");
+ return false;
+ }
+ if (x != NULL && priv == NULL)
+ {
+ Debug("StartSSL Error: #2\n");
+ return false;
+ }
+ if (ssl_timeout == 0)
+ {
+ ssl_timeout = TIMEOUT_SSL_CONNECT;
+ }
+
+ if (sock->SecureMode)
+ {
+ //Debug("StartSSL Error: #3\n");
+ // SSL communication has already started
+ return true;
+ }
+
+ Lock(sock->ssl_lock);
+ if (sock->SecureMode)
+ {
+ //Debug("StartSSL Error: #4\n");
+ // SSL communication has already started
+ Unlock(sock->ssl_lock);
+ return true;
+ }
+
+ ssl_ctx = NewSSLCtx();
+
+ Lock(openssl_lock);
+ {
+ if (sock->ServerMode)
+ {
+ SSL_CTX_set_ssl_version(ssl_ctx, SSLv23_method());
+
+ Unlock(openssl_lock);
+ AddChainSslCertOnDirectory(ssl_ctx);
+ Lock(openssl_lock);
+ }
+ else
+ {
+ if (client_tls == false)
+ {
+ SSL_CTX_set_ssl_version(ssl_ctx, SSLv3_method());
+ }
+ else
+ {
+ SSL_CTX_set_ssl_version(ssl_ctx, TLSv1_client_method());
+ }
+ }
+ sock->ssl = SSL_new(ssl_ctx);
+ SSL_set_fd(sock->ssl, (int)sock->socket);
+
+#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
+ if (sock->ServerMode == false && client_tls)
+ {
+ if (IsEmptyStr(sni_hostname) == false)
+ {
+ // Set the SNI host name
+ SSL_set_tlsext_host_name(sock->ssl, sni_hostname);
+ }
+ }
+#endif // SSL_CTRL_SET_TLSEXT_HOSTNAME
+ }
+ Unlock(openssl_lock);
+
+ if (x != NULL)
+ {
+ // Check the certificate and the private key
+ if (CheckXandK(x, priv))
+ {
+ // Use the certificate
+ x509 = x->x509;
+ key = priv->pkey;
+
+ Lock(openssl_lock);
+ {
+ SSL_use_certificate(sock->ssl, x509);
+ SSL_use_PrivateKey(sock->ssl, key);
+ }
+ Unlock(openssl_lock);
+ }
+ }
+
+ if (sock->WaitToUseCipher != NULL)
+ {
+ // Set the cipher algorithm name to want to use
+ Lock(openssl_lock);
+ {
+ SSL_set_cipher_list(sock->ssl, sock->WaitToUseCipher);
+ }
+ Unlock(openssl_lock);
+ }
+
+ if (sock->ServerMode)
+ {
+// Lock(ssl_connect_lock);
+
+// Run the time-out thread for SOLARIS
+#ifdef UNIX_SOLARIS
+ ttparam = NewSocketTimeout(sock);
+#endif // UNIX_SOLARIS
+
+ // Server mode
+ if (SSL_accept(sock->ssl) <= 0)
+ {
+
+// Stop the timeout thread
+#ifdef UNIX_SOLARIS
+ FreeSocketTimeout(ttparam);
+#endif // UNIX_SOLARIS
+
+ // Unlock(ssl_connect_lock);
+ // SSL-Accept failure
+ Lock(openssl_lock);
+ {
+ SSL_free(sock->ssl);
+ sock->ssl = NULL;
+ }
+ Unlock(openssl_lock);
+
+ Unlock(sock->ssl_lock);
+ Debug("StartSSL Error: #5\n");
+ FreeSSLCtx(ssl_ctx);
+ return false;
+ }
+
+#ifdef SSL_CTRL_SET_TLSEXT_HOSTNAME
+#ifdef TLSEXT_NAMETYPE_host_name
+ if (true)
+ {
+ // Get the SNI host name
+ const char *sni_recv_hostname = SSL_get_servername(sock->ssl, TLSEXT_NAMETYPE_host_name);
+
+ if (IsEmptyStr((char *)sni_recv_hostname) == false)
+ {
+ StrCpy(sock->SniHostname, sizeof(sock->SniHostname), (char *)sni_recv_hostname);
+ }
+ }
+#endif // TLSEXT_NAMETYPE_host_name
+#endif // SSL_CTRL_SET_TLSEXT_HOSTNAME
+
+// Stop the timeout thread
+#ifdef UNIX_SOLARIS
+ FreeSocketTimeout(ttparam);
+#endif // UNIX_SOLARIS
+
+ // Unlock(ssl_connect_lock);
+ }
+ else
+ {
+ prev_timeout = GetTimeout(sock);
+ SetTimeout(sock, ssl_timeout);
+ Lock(ssl_connect_lock);
+ // Client mode
+ if (SSL_connect(sock->ssl) <= 0)
+ {
+ Unlock(ssl_connect_lock);
+ // SSL-connect failure
+ Lock(openssl_lock);
+ {
+ SSL_free(sock->ssl);
+ sock->ssl = NULL;
+ }
+ Unlock(openssl_lock);
+
+ Unlock(sock->ssl_lock);
+ Debug("StartSSL Error: #5\n");
+ SetTimeout(sock, prev_timeout);
+ FreeSSLCtx(ssl_ctx);
+ return false;
+ }
+ Unlock(ssl_connect_lock);
+ SetTimeout(sock, prev_timeout);
+ }
+
+ // SSL communication is initiated
+ sock->SecureMode = true;
+
+ // Get the certificate of the remote host
+ Lock(openssl_lock);
+ {
+ x509 = SSL_get_peer_certificate(sock->ssl);
+ }
+ Unlock(openssl_lock);
+
+ if (x509 == NULL)
+ {
+ // The certificate does not exist on the remote host
+ sock->RemoteX = NULL;
+ }
+ else
+ {
+ // Got a certificate
+ sock->RemoteX = X509ToX(x509);
+ }
+
+ // Get the certificate of local host
+ Lock(openssl_lock);
+ {
+ x509 = SSL_get_certificate(sock->ssl);
+ }
+ Unlock(openssl_lock);
+
+ if (x509 == NULL)
+ {
+ // The certificate does not exist on the remote host
+ sock->LocalX = NULL;
+ }
+ else
+ {
+ X *local_x;
+ // Got a certificate
+ local_x = X509ToX(x509);
+ local_x->do_not_free = true;
+ sock->LocalX = CloneX(local_x);
+ FreeX(local_x);
+ }
+
+ // Automatic retry mode
+ SSL_set_mode(sock->ssl, SSL_MODE_AUTO_RETRY);
+
+ // Strange flag
+ SSL_set_mode(sock->ssl, SSL_MODE_ACCEPT_MOVING_WRITE_BUFFER);
+
+ sock->ssl_ctx = ssl_ctx;
+
+ // Get the algorithm name used to encrypt
+ Lock(openssl_lock);
+ {
+ sock->CipherName = CopyStr((char *)SSL_get_cipher(sock->ssl));
+ }
+ Unlock(openssl_lock);
+
+ Unlock(sock->ssl_lock);
+
+ return true;
+}
+
+// Set the flag to indicate that the socket doesn't require reading
+void SetNoNeedToRead(SOCK *sock)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+
+ sock->NoNeedToRead = true;
+}
+
+// TCP-SSL receive
+UINT SecureRecv(SOCK *sock, void *data, UINT size)
+{
+ SOCKET s;
+ int ret, e = 0;
+ SSL *ssl;
+
+#ifdef UNIX_SOLARIS
+ SOCKET_TIMEOUT_PARAM *ttparam;
+#endif //UNIX_SOLARIS
+
+ s = sock->socket;
+ ssl = sock->ssl;
+
+ if (sock->AsyncMode)
+ {
+ // Confirm whether the data is readable even 1 byte in the case of asynchronous mode.
+ // To read data results blocking, if there is no readable data.
+ // We must avoid blocking.
+ char c;
+ Lock(sock->ssl_lock);
+ {
+ if (sock->Connected == false)
+ {
+ Unlock(sock->ssl_lock);
+ Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ return 0;
+ }
+ ret = SSL_peek(ssl, &c, sizeof(c));
+ }
+ Unlock(sock->ssl_lock);
+ if (ret == 0)
+ {
+ // The communication have been disconnected
+ Disconnect(sock);
+ Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ return 0;
+ }
+ if (ret < 0)
+ {
+ // An error has occurred
+ e = SSL_get_error(ssl, ret);
+ if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_SSL)
+ {
+ // Packet has not arrived yet, that is not to be read
+ return SOCK_LATER;
+ }
+ }
+ }
+
+ // Receive
+ Lock(sock->ssl_lock);
+ {
+ if (sock->Connected == false)
+ {
+ Unlock(sock->ssl_lock);
+ Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ return 0;
+ }
+
+#ifdef OS_UNIX
+ if (sock->AsyncMode == false)
+ {
+ sock->CallingThread = pthread_self();
+ }
+#endif // OS_UNIX
+
+// Run the time-out thread for SOLARIS
+#ifdef UNIX_SOLARIS
+ ttparam = NewSocketTimeout(sock);
+#endif // UNIX_SOLARIS
+
+ ret = SSL_read(ssl, data, size);
+
+// Stop the timeout thread
+#ifdef UNIX_SOLARIS
+ FreeSocketTimeout(ttparam);
+#endif // UNIX_SOLARIS
+
+
+#ifdef OS_UNIX
+ if (sock->AsyncMode == false)
+ {
+ sock->CallingThread = 0;
+ }
+#endif // OS_UNIX
+
+ if (ret < 0)
+ {
+ e = SSL_get_error(ssl, ret);
+ }
+
+ }
+ Unlock(sock->ssl_lock);
+ if (ret > 0)
+ {
+ // Successful reception
+ sock->RecvSize += (UINT64)ret;
+ sock->RecvNum++;
+ return (UINT)ret;
+ }
+ if (ret == 0)
+ {
+ // Disconnect the communication
+ Disconnect(sock);
+ //Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ return 0;
+ }
+ if (sock->AsyncMode)
+ {
+ if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_SSL)
+ {
+ // Packet has not yet arrived
+ return SOCK_LATER;
+ }
+ }
+ Disconnect(sock);
+ Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ return 0;
+}
+
+// TCP-SSL transmission
+UINT SecureSend(SOCK *sock, void *data, UINT size)
+{
+ SOCKET s;
+ int ret, e;
+ SSL *ssl;
+ s = sock->socket;
+ ssl = sock->ssl;
+
+ if (sock->AsyncMode)
+ {
+ // Asynchronous mode
+ SSL_set_mode(ssl, SSL_MODE_ENABLE_PARTIAL_WRITE);
+ }
+
+ // Transmission
+ Lock(sock->ssl_lock);
+ {
+ if (sock->Connected == false)
+ {
+ Unlock(sock->ssl_lock);
+ Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ return 0;
+ }
+
+ ret = SSL_write(ssl, data, size);
+ if (ret < 0)
+ {
+ e = SSL_get_error(ssl, ret);
+ }
+ }
+ Unlock(sock->ssl_lock);
+
+ if (ret > 0)
+ {
+ // Successful transmission
+ sock->SendSize += (UINT64)ret;
+ sock->SendNum++;
+ sock->WriteBlocked = false;
+ return (UINT)ret;
+ }
+ if (ret == 0)
+ {
+ // Disconnect
+ Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ Disconnect(sock);
+ return 0;
+ }
+
+ if (sock->AsyncMode)
+ {
+ // Confirmation of the error value
+ if (e == SSL_ERROR_WANT_READ || e == SSL_ERROR_WANT_WRITE || e == SSL_ERROR_SSL)
+ {
+ sock->WriteBlocked = true;
+ return SOCK_LATER;
+ }
+ Debug("%s %u e=%u\n", __FILE__, __LINE__, e);
+ }
+ //Debug("%s %u SecureRecv() Disconnect\n", __FILE__, __LINE__);
+ Disconnect(sock);
+ return 0;
+}
+
+// Peep the TCP
+UINT Peek(SOCK *sock, void *data, UINT size)
+{
+ SOCKET s;
+ int ret;
+
+ // Validate arguments
+ if (sock == NULL || data == NULL || size == 0)
+ {
+ return 0;
+ }
+ if (sock->Type == SOCK_INPROC)
+ {
+ return 0;
+ }
+ if (sock->Type != SOCK_TCP || sock->Connected == false || sock->ListenMode != false ||
+ sock->socket == INVALID_SOCKET)
+ {
+ return 0;
+ }
+ if (sock->AsyncMode)
+ {
+ return 0;
+ }
+
+ // Receive
+ s = sock->socket;
+
+ ret = recv(s, data, size, MSG_PEEK);
+
+ //Debug("Peek: %u\n", ret);
+
+ if (ret > 0)
+ {
+ return ret;
+ }
+
+ return 0;
+}
+
+// TCP receive
+UINT Recv(SOCK *sock, void *data, UINT size, bool secure)
+{
+ SOCKET s;
+ int ret;
+
+#ifdef UNIX_SOLARIS
+ SOCKET_TIMEOUT_PARAM *ttparam;
+#endif //UNIX_SOLARIS
+
+ // Validate arguments
+ if (sock == NULL || data == NULL || size == 0)
+ {
+ return 0;
+ }
+
+ sock->NoNeedToRead = false;
+
+ if (sock->Type == SOCK_INPROC)
+ {
+ return RecvInProc(sock, data, size);
+ }
+ if (sock->Type != SOCK_TCP || sock->Connected == false || sock->ListenMode != false ||
+ sock->socket == INVALID_SOCKET)
+ {
+ return 0;
+ }
+ if (secure != false && sock->SecureMode == false)
+ {
+ return 0;
+ }
+
+ if (secure)
+ {
+ return SecureRecv(sock, data, size);
+ }
+
+ // Receive
+ s = sock->socket;
+
+
+#ifdef OS_UNIX
+ if (sock->AsyncMode == false)
+ {
+ sock->CallingThread = pthread_self();
+ }
+#endif // OS_UNIX
+
+// Start of the timeout thread for SOLARIS
+#ifdef UNIX_SOLARIS
+ ttparam = NewSocketTimeout(sock);
+#endif // UNIX_SOLARIS
+
+ ret = recv(s, data, size, 0);
+
+// Stop the timeout thread
+#ifdef UNIX_SOLARIS
+ FreeSocketTimeout(ttparam);
+#endif // UNIX_SOLARIS
+
+#ifdef OS_UNIX
+ if (sock->AsyncMode == false)
+ {
+ sock->CallingThread = 0;
+ }
+#endif // OS_UNIX
+
+ if (ret > 0)
+ {
+ // Successful reception
+ Lock(sock->lock);
+ {
+ sock->RecvSize += (UINT64)ret;
+ sock->SendNum++;
+ }
+ Unlock(sock->lock);
+ return (UINT)ret;
+ }
+
+ // Transmission failure
+ if (sock->AsyncMode)
+ {
+ // In asynchronous mode, examine the error
+ if (ret == SOCKET_ERROR)
+ {
+#ifdef OS_WIN32
+ if (WSAGetLastError() == WSAEWOULDBLOCK)
+ {
+ // In blocking
+ return SOCK_LATER;
+ }
+ else
+ {
+ //Debug("Socket Error: %u\n", WSAGetLastError());
+ }
+#else // OS_WIN32
+ if (errno == EAGAIN)
+ {
+ // In blocking
+ return SOCK_LATER;
+ }
+#endif // OS_WIN32
+ }
+ }
+
+ // Disconnected
+ Disconnect(sock);
+ return 0;
+}
+
+// TCP transmission
+UINT Send(SOCK *sock, void *data, UINT size, bool secure)
+{
+ SOCKET s;
+ int ret;
+ // Validate arguments
+ if (sock == NULL || data == NULL || size == 0)
+ {
+ return 0;
+ }
+ if (sock->Type == SOCK_INPROC)
+ {
+ return SendInProc(sock, data, size);
+ }
+ size = MIN(size, MAX_SEND_BUF_MEM_SIZE);
+ if (sock->Type != SOCK_TCP || sock->Connected == false || sock->ListenMode != false ||
+ sock->socket == INVALID_SOCKET)
+ {
+ return 0;
+ }
+ if (secure != false && sock->SecureMode == false)
+ {
+ return 0;
+ }
+
+ if (secure)
+ {
+ return SecureSend(sock, data, size);
+ }
+
+ // Transmission
+ s = sock->socket;
+ ret = send(s, data, size, 0);
+ if (ret > 0)
+ {
+ // Successful transmission
+ Lock(sock->lock);
+ {
+ sock->SendSize += (UINT64)ret;
+ sock->SendNum++;
+ }
+ Unlock(sock->lock);
+ sock->WriteBlocked = false;
+ return (UINT)ret;
+ }
+
+ // Transmission failure
+ if (sock->AsyncMode)
+ {
+ // In asynchronous mode, examine the error
+ if (ret == SOCKET_ERROR)
+ {
+#ifdef OS_WIN32
+ if (WSAGetLastError() == WSAEWOULDBLOCK)
+ {
+ // In blocking
+ sock->WriteBlocked = true;
+ return SOCK_LATER;
+ }
+ else
+ {
+ //Debug("Socket Error: %u\n", WSAGetLastError());
+ }
+#else // OS_WIN32
+ if (errno == EAGAIN)
+ {
+ // In blocking
+ sock->WriteBlocked = true;
+ return SOCK_LATER;
+ }
+#endif // OS_WIN32
+ }
+ }
+
+ // Disconnected
+ Disconnect(sock);
+ return 0;
+}
+
+// Get the time-out value (in milliseconds)
+UINT GetTimeout(SOCK *sock)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return INFINITE;
+ }
+ if (sock->Type != SOCK_TCP && sock->Type != SOCK_INPROC)
+ {
+ return INFINITE;
+ }
+
+ return sock->TimeOut;
+}
+
+// Setting the time-out value (in milliseconds)
+void SetTimeout(SOCK *sock, UINT timeout)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+ if (sock->Type == SOCK_UDP)
+ {
+ return;
+ }
+
+ if (timeout == INFINITE)
+ {
+ timeout = TIMEOUT_INFINITE;
+ }
+
+ sock->TimeOut = timeout;
+
+// Debug("SetTimeout(%u)\n",timeout);
+
+ if (sock->Type != SOCK_INPROC)
+ {
+#ifdef OS_WIN32
+ setsockopt(sock->socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&timeout, sizeof(UINT));
+ setsockopt(sock->socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&timeout, sizeof(UINT));
+#endif
+
+#ifdef OS_UNIX
+#ifndef UNIX_SOLARIS
+ {
+ struct timeval tv_timeout;
+
+ tv_timeout.tv_sec = timeout / 1000; // miliseconds to seconds
+ tv_timeout.tv_usec = (timeout % 1000) * 1000; // miliseconds to microseconds
+
+ setsockopt(sock->socket, SOL_SOCKET, SO_SNDTIMEO, (char *)&tv_timeout, sizeof(tv_timeout));
+ setsockopt(sock->socket, SOL_SOCKET, SO_RCVTIMEO, (char *)&tv_timeout, sizeof(tv_timeout));
+ }
+#endif // UNIX_SOLARIS
+#endif // OS_UNIX
+ }
+}
+
+// Initialize the connection acceptance
+void AcceptInit(SOCK *s)
+{
+ char tmp[MAX_SIZE];
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+ Zero(tmp, sizeof(tmp));
+ if (GetHostName(tmp, sizeof(tmp), &s->RemoteIP) == false ||
+ IsEmptyStr(tmp))
+ {
+ IPToStr(tmp, sizeof(tmp), &s->RemoteIP);
+ }
+
+ if (s->RemoteHostname != NULL)
+ {
+ Free(s->RemoteHostname);
+ }
+
+ s->RemoteHostname = CopyStr(tmp);
+}
+
+// TCP connection acceptance (IPv4)
+SOCK *Accept(SOCK *sock)
+{
+ SOCK *ret;
+ SOCKET s, new_socket;
+ int size;
+ struct sockaddr_in addr;
+ bool true_flag = true;
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return NULL;
+ }
+ if (sock->Type == SOCK_INPROC)
+ {
+ return AcceptInProc(sock);
+ }
+ if (sock->Type == SOCK_REVERSE_LISTEN)
+ {
+ return AcceptReverse(sock);
+ }
+ if (sock->Type == SOCK_RUDP_LISTEN)
+ {
+ return AcceptRUDP(sock);
+ }
+ if (sock->ListenMode == false || sock->Type != SOCK_TCP || sock->ServerMode == false)
+ {
+ return NULL;
+ }
+ if (sock->CancelAccept)
+ {
+ return NULL;
+ }
+ if (sock->IPv6)
+ {
+ return Accept6(sock);
+ }
+
+ s = sock->socket;
+ if (s == INVALID_SOCKET)
+ {
+ return NULL;
+ }
+ Zero(&addr, sizeof(addr));
+ size = sizeof(addr);
+
+#ifdef OS_UNIX
+#ifdef UNIX_LINUX
+ UnixIgnoreSignalForThread(SIGUSR1);
+#endif // UNIX_LINUX
+ sock->CallingThread = pthread_self();
+#endif // OS_UNIX
+
+#ifdef OS_WIN32
+ if (sock->EnableConditionalAccept)
+ {
+ new_socket = Win32Accept(sock, s, (struct sockaddr *)&addr,(int *)&size, false);
+ }
+ else
+ {
+ new_socket = accept(s, (struct sockaddr *)&addr,(int *)&size);
+ }
+#else // OS_WIN32
+ new_socket = accept(s, (struct sockaddr *)&addr,(int *)&size);
+#endif // OS_WIN32
+
+#ifdef OS_UNIX
+ sock->CallingThread = 0;
+#endif // OS_UNIX
+
+ if (new_socket == INVALID_SOCKET)
+ {
+ if (sock->CancelAccept)
+ {
+ sock->AcceptCanceled = true;
+ }
+ return NULL;
+ }
+ if (sock->CancelAccept)
+ {
+ sock->AcceptCanceled = true;
+ closesocket(new_socket);
+ return NULL;
+ }
+
+ ret = NewSock();
+ ret->socket = new_socket;
+ ret->Connected = true;
+ ret->AsyncMode = false;
+ ret->Type = SOCK_TCP;
+ ret->ServerMode = true;
+ ret->SecureMode = false;
+
+ // Configuring the TCP options
+ setsockopt(ret->socket, IPPROTO_TCP, TCP_NODELAY, (char *)&true_flag, sizeof(bool));
+
+ // Initialization of the time-out value
+ SetTimeout(ret, TIMEOUT_INFINITE);
+
+ // Socket information
+ QuerySocketInformation(ret);
+
+ if (IsLocalHostIP(&ret->RemoteIP) == false)
+ {
+ ret->IpClientAdded = true;
+ AddIpClient(&ret->RemoteIP);
+ }
+
+ if (IsZeroIp(&sock->LocalIP) == false && IsLocalHostIP(&sock->LocalIP) == false)
+ {
+ IP current_ip;
+
+ if (GetCurrentGlobalIP(¤t_ip, false) == false)
+ {
+ SetCurrentGlobalIP(&sock->LocalIP, false);
+ }
+ }
+
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_NATIVE_V4);
+
+ return ret;
+}
+
+// TCP connection acceptance (IPv6)
+SOCK *Accept6(SOCK *sock)
+{
+ SOCK *ret;
+ SOCKET s, new_socket;
+ int size;
+ struct sockaddr_in6 addr;
+ bool true_flag = true;
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return NULL;
+ }
+ if (sock->ListenMode == false || sock->Type != SOCK_TCP || sock->ServerMode == false)
+ {
+ return NULL;
+ }
+ if (sock->CancelAccept)
+ {
+ return NULL;
+ }
+ if (sock->IPv6 == false)
+ {
+ return NULL;
+ }
+
+ s = sock->socket;
+ if (s == INVALID_SOCKET)
+ {
+ return NULL;
+ }
+ Zero(&addr, sizeof(addr));
+ size = sizeof(addr);
+
+#ifdef OS_UNIX
+#ifdef UNIX_LINUX
+ UnixIgnoreSignalForThread(SIGUSR1);
+#endif // UNIX_LINUX
+ sock->CallingThread = pthread_self();
+#endif // OS_UNIX
+
+#ifdef OS_WIN32
+ if (sock->EnableConditionalAccept)
+ {
+ new_socket = Win32Accept(sock, s, (struct sockaddr *)&addr,(int *)&size, true);
+ }
+ else
+ {
+ new_socket = accept(s, (struct sockaddr *)&addr,(int *)&size);
+ }
+#else // OS_WIN32
+ new_socket = accept(s, (struct sockaddr *)&addr,(int *)&size);
+#endif // OS_WIN32
+
+#ifdef OS_UNIX
+ sock->CallingThread = 0;
+#endif // OS_UNIX
+
+ if (new_socket == INVALID_SOCKET)
+ {
+ if (sock->CancelAccept)
+ {
+ sock->AcceptCanceled = true;
+ }
+ return NULL;
+ }
+ if (sock->CancelAccept)
+ {
+ sock->AcceptCanceled = true;
+ closesocket(new_socket);
+ return NULL;
+ }
+
+ ret = NewSock();
+ ret->socket = new_socket;
+ ret->Connected = true;
+ ret->AsyncMode = false;
+ ret->Type = SOCK_TCP;
+ ret->ServerMode = true;
+ ret->SecureMode = false;
+
+ // Configuring the TCP options
+ setsockopt(ret->socket, IPPROTO_TCP, TCP_NODELAY, (char *)&true_flag, sizeof(bool));
+
+ // Initialize the time-out value
+ SetTimeout(ret, TIMEOUT_INFINITE);
+
+ // Socket information
+ QuerySocketInformation(ret);
+
+ if (IsLocalHostIP(&ret->RemoteIP) == false)
+ {
+ ret->IpClientAdded = true;
+ AddIpClient(&ret->RemoteIP);
+ }
+ if (IsZeroIp(&sock->LocalIP) == false && IsLocalHostIP(&sock->LocalIP) == false)
+ {
+ IP current_ip;
+
+ if (GetCurrentGlobalIP(¤t_ip, true) == false)
+ {
+ SetCurrentGlobalIP(&sock->LocalIP, true);
+ }
+ }
+
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_NATIVE_V6);
+
+ return ret;
+}
+
+// Standby for TCP (IPv6)
+SOCK *Listen6(UINT port)
+{
+ return ListenEx6(port, false);
+}
+SOCK *ListenEx6(UINT port, bool local_only)
+{
+ return ListenEx62(port, local_only, false);
+}
+SOCK *ListenEx62(UINT port, bool local_only, bool enable_ca)
+{
+ SOCKET s;
+ SOCK *sock;
+ struct sockaddr_in6 addr;
+ struct in6_addr in;
+ bool true_flag = true;
+ bool disable_conditional_accept = false;
+ IP localhost;
+ UINT backlog = SOMAXCONN;
+ // Validate arguments
+ if (port == 0 || port >= 65536)
+ {
+ return NULL;
+ }
+
+#ifdef OS_WIN32
+ if (MsIsVista() == false)
+ {
+ // Disable the Conditional Accept due to a bug in Windows
+ enable_ca = false;
+ }
+#endif // OS_WIN32
+
+ // Initialization
+ Zero(&addr, sizeof(addr));
+ Zero(&in, sizeof(in));
+ GetLocalHostIP6(&localhost);
+
+ addr.sin6_port = htons((UINT)port);
+ addr.sin6_family = AF_INET6;
+
+ if (local_only)
+ {
+ IPToInAddr6(&addr.sin6_addr, &localhost);
+
+ enable_ca = false;
+ }
+
+ // Creating a socket
+ s = socket(AF_INET6, SOCK_STREAM, 0);
+ if (s == INVALID_SOCKET)
+ {
+ return NULL;
+ }
+
+#ifdef OS_UNIX
+ // It is necessary to set the IPv6 Only flag on a UNIX system
+ setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &true_flag, sizeof(true_flag));
+#endif // OS_UNIX
+
+ //SetSocketSendRecvBufferSize(s, SOCKET_BUFFER_SIZE);
+
+#ifdef OS_UNIX
+ // This only have enabled for UNIX system since there is a bug
+ // in the implementation of REUSEADDR in Windows OS
+ setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&true_flag, sizeof(bool));
+#endif // OS_UNIX
+
+ if (bind(s, (struct sockaddr *)&addr, sizeof(struct sockaddr_in6)) != 0)
+ {
+ // Bind failure
+ closesocket(s);
+ return NULL;
+ }
+
+#ifdef OS_WIN32
+ if (enable_ca)
+ {
+ if (MsIsWinXPOrGreater())
+ {
+ setsockopt(s, SOL_SOCKET, SO_CONDITIONAL_ACCEPT, (char *)&true_flag, sizeof(bool));
+
+ backlog = 1;
+ }
+ }
+#endif // OS_WIN32
+
+ if (listen(s, backlog))
+ {
+ // Listen failure
+ closesocket(s);
+ return NULL;
+ }
+
+ // Success
+ sock = NewSock();
+ sock->Connected = false;
+ sock->AsyncMode = false;
+ sock->ServerMode = true;
+ sock->Type = SOCK_TCP;
+ sock->socket = s;
+ sock->ListenMode = true;
+ sock->SecureMode = false;
+ sock->LocalPort = port;
+ sock->IPv6 = true;
+ sock->LocalOnly = local_only;
+ sock->EnableConditionalAccept = enable_ca;
+
+ return sock;
+}
+
+// Standby for the TCP
+SOCK *Listen(UINT port)
+{
+ return ListenEx(port, false);
+}
+SOCK *ListenEx(UINT port, bool local_only)
+{
+ return ListenEx2(port, local_only, false);
+}
+SOCK *ListenEx2(UINT port, bool local_only, bool enable_ca)
+{
+ SOCKET s;
+ SOCK *sock;
+ struct sockaddr_in addr;
+ struct in_addr in;
+ bool true_flag = true;
+ IP localhost;
+ UINT backlog = SOMAXCONN;
+ // Validate arguments
+ if (port == 0 || port >= 65536)
+ {
+ return NULL;
+ }
+
+#ifdef OS_WIN32
+ if (MsIsVista() == false)
+ {
+ // Disable the Conditional Accept due to a bug in Windows
+ enable_ca = false;
+ }
+#endif // OS_WIN32
+
+ // Initialization
+ Zero(&addr, sizeof(addr));
+ Zero(&in, sizeof(in));
+ SetIP(&localhost, 127, 0, 0, 1);
+
+ addr.sin_port = htons((UINT)port);
+ *((UINT *)&addr.sin_addr) = htonl(INADDR_ANY);
+ addr.sin_family = AF_INET;
+
+ if (local_only)
+ {
+ IPToInAddr(&addr.sin_addr, &localhost);
+
+ enable_ca = false;
+ }
+
+ // Creating a socket
+ s = socket(AF_INET, SOCK_STREAM, 0);
+ if (s == INVALID_SOCKET)
+ {
+ return NULL;
+ }
+
+ //SetSocketSendRecvBufferSize(s, SOCKET_BUFFER_SIZE);
+
+#ifdef OS_UNIX
+ // This only have enabled for UNIX system since there is a bug
+ // in the implementation of REUSEADDR in Windows OS
+ setsockopt(s, SOL_SOCKET, SO_REUSEADDR, (char *)&true_flag, sizeof(bool));
+#endif // OS_UNIX
+
+ if (bind(s, (struct sockaddr *)&addr, sizeof(struct sockaddr_in)) != 0)
+ {
+ // Bind failure
+ closesocket(s);
+ return NULL;
+ }
+
+#ifdef OS_WIN32
+ if (enable_ca)
+ {
+ if (MsIsWinXPOrGreater())
+ {
+ setsockopt(s, SOL_SOCKET, SO_CONDITIONAL_ACCEPT, (char *)&true_flag, sizeof(bool));
+
+ backlog = 1;
+ }
+ }
+#endif // OS_WIN32
+
+ if (listen(s, backlog))
+ {
+ // Listen failure
+ closesocket(s);
+ return NULL;
+ }
+
+ // Success
+ sock = NewSock();
+ sock->Connected = false;
+ sock->AsyncMode = false;
+ sock->ServerMode = true;
+ sock->Type = SOCK_TCP;
+ sock->socket = s;
+ sock->ListenMode = true;
+ sock->SecureMode = false;
+ sock->LocalPort = port;
+ sock->LocalOnly = local_only;
+ sock->EnableConditionalAccept = enable_ca;
+
+ return sock;
+}
+
+// TCP disconnect
+void Disconnect(SOCK *sock)
+{
+ SOCKET s;
+ bool true_flag = true;
+ bool false_flag = false;
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+
+ sock->Disconnecting = true;
+
+#ifdef OS_UNIX
+ UnixFreeAsyncSocket(sock);
+#endif // UnixFreeAsyncSocket
+
+ if (sock->Type == SOCK_TCP && sock->ListenMode)
+ {
+ bool no_tcp_check_port = false;
+
+ // Connect to localhost if the socket is in listening
+ sock->CancelAccept = true;
+
+#ifdef UNIX_LINUX
+ {
+ pthread_t t = sock->CallingThread;
+
+ // Send a signal to the socket to abort accept() forcibly on Linux
+ if (t != 0)
+ {
+ pthread_kill(t, SIGUSR1);
+
+ SleepThread(200);
+ }
+ }
+#endif // UNIX_LINUX
+
+#ifdef OS_WIN32
+ if (sock->hAcceptEvent != NULL)
+ {
+ SetEvent(sock->hAcceptEvent);
+
+ no_tcp_check_port = true;
+ }
+#endif // OS_WIN32
+
+ if (sock->AcceptCanceled == false)
+ {
+ if (no_tcp_check_port == false)
+ {
+ if (sock->IPv6 == false)
+ {
+ CheckTCPPort("127.0.0.1", sock->LocalPort);
+ }
+ else
+ {
+ CheckTCPPort("::1", sock->LocalPort);
+ }
+ }
+ }
+ }
+
+ Lock(disconnect_function_lock);
+
+ Lock(sock->disconnect_lock);
+
+ if (sock->Type == SOCK_TCP)
+ {
+ if (sock->socket != INVALID_SOCKET)
+ {
+ // Forced disconnection flag
+ #ifdef SO_DONTLINGER
+ setsockopt(sock->socket, SOL_SOCKET, SO_DONTLINGER, (char *)&true_flag, sizeof(bool));
+ #else // SO_DONTLINGER
+ 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));
+ }
+
+ // TCP socket
+ Lock(sock->lock);
+ {
+ if (sock->socket == INVALID_SOCKET)
+ {
+ Unlock(sock->lock);
+ Unlock(sock->disconnect_lock);
+ Unlock(disconnect_function_lock);
+ return;
+ }
+ s = sock->socket;
+
+ if (sock->Connected)
+ {
+ struct linger ling;
+ Zero(&ling, sizeof(ling));
+
+
+#if 0
+ // SSL disconnect
+ Lock(sock->ssl_lock);
+ {
+ if (sock->SecureMode)
+ {
+ SSL_shutdown(sock->ssl);
+ }
+ }
+ Unlock(sock->ssl_lock);
+#endif
+ // Disconnect
+ shutdown(s, 2);
+ }
+
+ // Close the socket
+ closesocket(s);
+
+#ifdef OS_UNIX
+#ifdef FIX_SSL_BLOCKING
+ if (sock->CallingThread != NULL)
+ {
+ pthread_kill(sock->CallingThread, 64);
+ }
+#endif // FIX_SSL_BLOCKING
+#endif // OS_UNIX
+
+ // Release the SSL
+ Lock(sock->ssl_lock);
+ {
+ if (sock->SecureMode)
+ {
+ if (sock->ssl != NULL)
+ {
+ Lock(openssl_lock);
+ {
+ SSL_free(sock->ssl);
+ FreeSSLCtx(sock->ssl_ctx);
+ }
+ Unlock(openssl_lock);
+ sock->ssl = NULL;
+ sock->ssl_ctx = NULL;
+ }
+ sock->Connected = false;
+ // Release the certificate
+ if (sock->RemoteX != NULL)
+ {
+ FreeX(sock->RemoteX);
+ sock->RemoteX = NULL;
+ }
+ if (sock->LocalX != NULL)
+ {
+ FreeX(sock->LocalX);
+ sock->LocalX = NULL;
+ }
+
+ // Cipher algorithm name
+ if (sock->CipherName != NULL)
+ {
+ Free(sock->CipherName);
+ sock->CipherName = NULL;
+ }
+ sock->SecureMode = false;
+ }
+ }
+ Unlock(sock->ssl_lock);
+
+ // Initialization
+ sock->socket = INVALID_SOCKET;
+ sock->Type = 0;
+ sock->AsyncMode = false;
+ sock->Connected = false;
+ sock->ListenMode = false;
+ sock->SecureMode = false;
+
+ if (sock->IpClientAdded)
+ {
+ DelIpClient(&sock->RemoteIP);
+ sock->IpClientAdded = false;
+ }
+ }
+ Unlock(sock->lock);
+
+ if (sock->BulkSendTube != NULL)
+ {
+ TubeDisconnect(sock->BulkSendTube);
+ }
+
+ if (sock->BulkRecvTube != NULL)
+ {
+ TubeDisconnect(sock->BulkRecvTube);
+ }
+ }
+ else if (sock->Type == SOCK_UDP)
+ {
+ // UDP socket
+ Lock(sock->lock);
+ {
+ if (sock->socket == INVALID_SOCKET)
+ {
+ Unlock(sock->lock);
+ Unlock(sock->disconnect_lock);
+ Unlock(disconnect_function_lock);
+ return;
+ }
+
+ s = sock->socket;
+
+ // Close the socket
+ closesocket(s);
+
+ // Initialization
+ sock->socket = INVALID_SOCKET;
+ sock->Type = 0;
+ sock->AsyncMode = false;
+ sock->Connected = false;
+ sock->ListenMode = false;
+ sock->SecureMode = false;
+ }
+ Unlock(sock->lock);
+ }
+ else if (sock->Type == SOCK_INPROC)
+ {
+ // In-process socket
+ if (sock->ListenMode)
+ {
+ // Stop the Accept process
+ sock->CancelAccept = true;
+
+ Set(sock->InProcAcceptEvent);
+
+ LockQueue(sock->InProcAcceptQueue);
+ {
+ while (true)
+ {
+ SOCK *ss = GetNext(sock->InProcAcceptQueue);
+ if (ss == NULL)
+ {
+ break;
+ }
+
+ Disconnect(ss);
+ ReleaseSock(ss);
+ }
+ }
+ UnlockQueue(sock->InProcAcceptQueue);
+ }
+ else
+ {
+ // Disconnect the Tube
+ TubeDisconnect(sock->SendTube);
+ TubeDisconnect(sock->RecvTube);
+
+ sock->socket = INVALID_SOCKET;
+ sock->AsyncMode = false;
+ sock->Connected = false;
+ sock->ListenMode = false;
+ sock->SecureMode = false;
+ }
+ }
+ else if (sock->Type == SOCK_RUDP_LISTEN)
+ {
+ // RUDP Listen socket
+ if (sock->ListenMode)
+ {
+ // Stop the Accept process
+ sock->CancelAccept = true;
+
+ Set(sock->R_UDP_Stack->NewSockConnectEvent);
+
+ sock->R_UDP_Stack->Halt = true;
+ Set(sock->R_UDP_Stack->HaltEvent);
+ SetSockEvent(sock->R_UDP_Stack->SockEvent);
+ }
+ }
+ else if (sock->Type == SOCK_REVERSE_LISTEN)
+ {
+ // Reverse Listen socket
+ if (sock->ListenMode)
+ {
+ // Stop the Accept process
+ sock->CancelAccept = true;
+
+ Set(sock->ReverseAcceptEvent);
+
+ LockQueue(sock->ReverseAcceptQueue);
+ {
+ while (true)
+ {
+ SOCK *ss = GetNext(sock->ReverseAcceptQueue);
+ if (ss == NULL)
+ {
+ break;
+ }
+
+ Disconnect(ss);
+ ReleaseSock(ss);
+ }
+ }
+ UnlockQueue(sock->ReverseAcceptQueue);
+ }
+ }
+ Unlock(sock->disconnect_lock);
+
+ Unlock(disconnect_function_lock);
+}
+
+typedef struct TCP_PORT_CHECK
+{
+ REF *ref;
+ char hostname[MAX_SIZE];
+ UINT port;
+ bool ok;
+} TCP_PORT_CHECK;
+
+// The thread to check the TCP port
+void CheckTCPPortThread(THREAD *thread, void *param)
+{
+ TCP_PORT_CHECK *c;
+ SOCK *s;
+ // Validate arguments
+ if (thread == NULL || param == NULL)
+ {
+ return;
+ }
+
+ c = (TCP_PORT_CHECK *)param;
+ AddRef(c->ref);
+ NoticeThreadInit(thread);
+
+ AddWaitThread(thread);
+
+ s = Connect(c->hostname, c->port);
+ if (s != NULL)
+ {
+ c->ok = true;
+ Disconnect(s);
+ ReleaseSock(s);
+ }
+
+ if (Release(c->ref) == 0)
+ {
+ Free(c);
+ }
+
+ DelWaitThread(thread);
+}
+
+// Check whether the TCP port can be connected
+bool CheckTCPPortEx(char *hostname, UINT port, UINT timeout)
+{
+ SOCK *s;
+ // Validate arguments
+ if (hostname == NULL || port == 0 || port >= 65536)
+ {
+ return false;
+ }
+
+ if (timeout == 0)
+ {
+ timeout = TIMEOUT_TCP_PORT_CHECK;
+ }
+
+ s = ConnectEx(hostname, port, timeout);
+ if (s == NULL)
+ {
+ return false;
+ }
+ else
+ {
+ Disconnect(s);
+ ReleaseSock(s);
+ return true;
+ }
+}
+bool CheckTCPPort(char *hostname, UINT port)
+{
+ return CheckTCPPortEx(hostname, port, TIMEOUT_TCP_PORT_CHECK);
+}
+
+#ifdef OS_UNIX
+// Connection with timeout (UNIX version)
+int connect_timeout(SOCKET s, struct sockaddr *addr, int size, int timeout, bool *cancel_flag)
+{
+ SOCKSET set;
+ bool ok = false;
+ UINT64 start_time;
+ // Validate arguments
+ if (s == INVALID_SOCKET || addr == NULL)
+ {
+ return -1;
+ }
+ if (timeout == 0)
+ {
+ timeout = TIMEOUT_TCP_PORT_CHECK;
+ }
+
+ UnixSetSocketNonBlockingMode(s, true);
+
+ start_time = Tick64();
+
+ while (true)
+ {
+ int ret;
+ ret = connect(s, addr, size);
+ if (ret == 0 || errno == EISCONN)
+ {
+ ok = true;
+ break;
+ }
+ else
+ {
+ if (((start_time + (UINT64)timeout) <= Tick64()) || (errno != EAGAIN && errno != EINPROGRESS && errno != EALREADY))
+ {
+ // Failure
+ break;
+ }
+ else if (*cancel_flag)
+ {
+ // Cancel
+ break;
+ }
+ else
+ {
+ // Connecting
+ SleepThread(50);
+ UnixSelectInner(1, (UINT *)&s, 1, (UINT *)&s, 100);
+ }
+ }
+ }
+
+ UnixSetSocketNonBlockingMode(s, false);
+
+ if (ok)
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+#else
+// Connection with timeout (Win32 version)
+int connect_timeout(SOCKET s, struct sockaddr *addr, int size, int timeout, bool *cancel_flag)
+{
+ UINT64 start_time;
+ bool ok = false;
+ bool timeouted = false;
+ WSAEVENT hEvent;
+ UINT zero = 0;
+ UINT tmp = 0;
+ UINT ret_size = 0;
+ bool is_nt = false;
+ // Validate arguments
+ if (s == INVALID_SOCKET || addr == NULL)
+ {
+ return -1;
+ }
+ if (timeout == 0)
+ {
+ timeout = TIMEOUT_TCP_PORT_CHECK;
+ }
+
+ is_nt = OS_IS_WINDOWS_NT(GetOsInfo()->OsType);
+
+ // Create an event
+ hEvent = CreateEvent(NULL, FALSE, FALSE, NULL);
+
+ // Associate the socket with the event
+ WSAEventSelect(s, hEvent, FD_CONNECT);
+
+ start_time = Tick64();
+
+ while (true)
+ {
+ int ret;
+
+ ret = connect(s, addr, size);
+
+ if (ret == 0)
+ {
+ ok = true;
+ break;
+ }
+ else
+ {
+ int err = WSAGetLastError();
+ //Debug("err=%u\n", err);
+ //Debug("cancel_flag=%u\n", *cancel_flag);
+ if (timeouted && ((err == WSAEALREADY) || (err == WSAEWOULDBLOCK && !is_nt)))
+ {
+ // Time-out
+ ok = false;
+ break;
+ }
+ if (*cancel_flag)
+ {
+ // Cancel
+ ok = false;
+ break;
+ }
+ if (err == WSAEISCONN || (err == WSAEINVAL && is_nt))
+ {
+ ok = true;
+ break;
+ }
+ if (((start_time + (UINT64)timeout) <= Tick64()) || (err != WSAEWOULDBLOCK && err != WSAEALREADY && (is_nt || err != WSAEINVAL)))
+ {
+ // Failure (timeout)
+ break;
+ }
+ else
+ {
+ SleepThread(10);
+ // Connecting
+ if (WaitForSingleObject(hEvent, 100) == WAIT_OBJECT_0)
+ {
+ timeouted = true;
+ }
+ }
+ }
+ }
+
+ // Remove the socket from the event
+ WSAEventSelect(s, hEvent, 0);
+
+ // Restore to synchronized socket
+ WSAIoctl(s, FIONBIO, &zero, sizeof(zero), &tmp, sizeof(tmp), &ret_size, NULL, NULL);
+
+ // Close the event
+ CloseHandle(hEvent);
+
+ if (ok)
+ {
+ return 0;
+ }
+ else
+ {
+ return -1;
+ }
+}
+#endif // OS_UNIX
+
+// Set the TOS value of the socket
+void SetSockTos(SOCK *s, int tos)
+{
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+ if (s->CurrentTos == tos)
+ {
+ return;
+ }
+
+#ifdef IP_TOS
+ setsockopt(s->socket, IPPROTO_IP, IP_TOS, (char *)&tos, sizeof(int));
+#endif // IP_TOS
+
+ s->CurrentTos = tos;
+}
+
+// Set the priority of the socket
+void SetSockHighPriority(SOCK *s, bool flag)
+{
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+ SetSockTos(s, (flag ? 16 : 0));
+}
+
+// Connect to the IPv4 host using a socket
+SOCKET ConnectTimeoutIPv4(IP *ip, UINT port, UINT timeout, bool *cancel_flag)
+{
+ SOCKET s;
+ struct sockaddr_in sockaddr4;
+ struct in_addr addr4;
+
+ Zero(&sockaddr4, sizeof(sockaddr4));
+ Zero(&addr4, sizeof(addr4));
+
+ // Generate a sockaddr_in
+ IPToInAddr(&addr4, ip);
+ sockaddr4.sin_port = htons((USHORT)port);
+ sockaddr4.sin_family = AF_INET;
+ sockaddr4.sin_addr.s_addr = addr4.s_addr;
+
+ // Socket creation
+ s = socket(AF_INET, SOCK_STREAM, 0);
+ if (s != INVALID_SOCKET)
+ {
+ // Connection
+ if (connect_timeout(s, (struct sockaddr *)&sockaddr4, sizeof(struct sockaddr_in), timeout, cancel_flag) != 0)
+ {
+ // Connection failure
+ closesocket(s);
+ s = INVALID_SOCKET;
+ }
+ }
+
+ return s;
+}
+
+// Identify whether the HTTPS server to be connected is a SoftEther VPN
+bool DetectIsServerSoftEtherVPN(SOCK *s)
+{
+ HTTP_HEADER *h;
+ char ip_str[MAX_SIZE];
+ char *send_str;
+ UINT content_len;
+ BUF *recv_buf;
+ void *socket_buffer;
+ UINT socket_buffer_size = 32768;
+ bool ok = false;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return false;
+ }
+
+ IPToStr(ip_str, sizeof(ip_str), &s->RemoteIP);
+
+ // Request generation
+ h = NewHttpHeaderEx("GET", "/", "HTTP/1.1", true);
+ AddHttpValue(h, NewHttpValue("X-VPN", "1"));
+ AddHttpValue(h, NewHttpValue("Host", ip_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Accept-Language", "ja"));
+ AddHttpValue(h, NewHttpValue("User-Agent", DEFAULT_USER_AGENT));
+ AddHttpValue(h, NewHttpValue("Pragma", "no-cache"));
+ AddHttpValue(h, NewHttpValue("Cache-Control", "no-cache"));
+ send_str = HttpHeaderToStr(h);
+ FreeHttpHeader(h);
+
+ // Transmission
+ if (SendAll(s, send_str, StrLen(send_str), true) == false)
+ {
+ Free(send_str);
+ return false;
+ }
+
+ Free(send_str);
+
+ // Receive
+ h = RecvHttpHeader(s);
+ if (h == NULL)
+ {
+ return false;
+ }
+
+ // Get the length of the content
+ content_len = GetContentLength(h);
+ FreeHttpHeader(h);
+
+ if (content_len == 0 || content_len >= (1024 * 1024))
+ {
+ return false;
+ }
+
+ // Receive contents
+ recv_buf = NewBuf();
+ socket_buffer = Malloc(socket_buffer_size);
+
+ while (true)
+ {
+ UINT recvsize = MIN(socket_buffer_size, content_len - recv_buf->Size);
+ UINT size;
+
+ if (recvsize == 0)
+ {
+ ok = true;
+ break;
+ }
+
+ size = Recv(s, socket_buffer, recvsize, true);
+ if (size == 0)
+ {
+ // Disconnected
+ break;
+ }
+
+ WriteBuf(recv_buf, socket_buffer, size);
+ }
+
+ SeekBuf(recv_buf, 0, 0);
+ Free(socket_buffer);
+
+ if (ok)
+ {
+ // Examine to confirm whether the incoming data is a SoftEther VPN protocol
+ char tmp[1024];
+
+ Zero(tmp, sizeof(tmp));
+
+ Copy(tmp, recv_buf->Buf, MIN(recv_buf->Size, (sizeof(tmp) - 1)));
+
+ ok = false;
+
+ if (StartWith(tmp, http_detect_server_startwith))
+ {
+ ok = true;
+ }
+ else if (InStr(tmp, http_detect_server_tag_future))
+ {
+ ok = true;
+ }
+ }
+
+ FreeBuf(recv_buf);
+
+ return ok;
+}
+
+// TCP connection thread
+void ConnectThreadForTcp(THREAD *thread, void *param)
+{
+ SOCK *sock;
+ char hostname[MAX_SIZE];
+ CONNECT_TCP_RUDP_PARAM *p = (CONNECT_TCP_RUDP_PARAM *)param;
+ if (thread == NULL || p == NULL)
+ {
+ return;
+ }
+
+ // Delay
+ if (p->Delay >= 1)
+ {
+ WaitEx(NULL, p->Delay, p->CancelFlag);
+ }
+
+ // Connecting process
+ IPToStr(hostname, sizeof(hostname), &p->Ip);
+ sock = ConnectEx3(hostname, p->Port, p->Timeout, p->CancelFlag, NULL, NULL, false, false, true);
+
+ if (sock != NULL && p->Tcp_SslNoTls)
+ {
+ bool ssl_ret = false;
+ // Attempt the SSL negotiation to take this opportunity
+ Lock(p->CancelLock);
+ {
+ if ((*p->CancelFlag) == false)
+ {
+ p->CancelDisconnectSock = sock;
+ AddRef(sock->ref);
+ }
+ else
+ {
+ Debug("User Cancel to StartSSL.\n");
+ goto LABEL_CANCEL;
+ }
+ }
+ Unlock(p->CancelLock);
+
+ // Start the SSL communication
+ ssl_ret = StartSSLEx(sock, NULL, NULL, p->Tcp_SslNoTls, 0, p->Hostname);
+
+ if (ssl_ret)
+ {
+ // Identify whether the HTTPS server to be connected is a SoftEther VPN
+ SetTimeout(sock, (10 * 1000));
+ ssl_ret = DetectIsServerSoftEtherVPN(sock);
+ SetTimeout(sock, INFINITE);
+
+ if (ssl_ret == false)
+ {
+ Debug("DetectIsServerSoftEtherVPN Error.\n");
+ }
+ }
+
+ Lock(p->CancelLock);
+ {
+ ReleaseSock(p->CancelDisconnectSock);
+ p->CancelDisconnectSock = NULL;
+LABEL_CANCEL:
+ DoNothing();
+ }
+ Unlock(p->CancelLock);
+
+ if (ssl_ret == false)
+ {
+ // SSL negotiation failure
+ Disconnect(sock);
+ ReleaseSock(sock);
+
+ Debug("Fail to StartSSL.\n");
+
+ sock = NULL;
+ }
+ }
+
+ p->Result_Tcp_Sock = sock;
+ p->Ok = (p->Result_Tcp_Sock == NULL ? false : true);
+ p->FinishedTick = Tick64();
+ p->Finished = true;
+
+ Set(p->FinishEvent);
+}
+
+// R-UDP over ICMP / over DNS connection thread
+void ConnectThreadForOverDnsOrIcmp(THREAD *thread, void *param)
+{
+ SOCK *sock;
+ CONNECT_TCP_RUDP_PARAM *p = (CONNECT_TCP_RUDP_PARAM *)param;
+ if (thread == NULL || p == NULL)
+ {
+ return;
+ }
+
+ // Delay
+ if (p->Delay >= 1)
+ {
+ WaitEx(NULL, p->Delay, p->CancelFlag);
+ }
+
+ // 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->Result_Nat_T_Sock = sock;
+ p->Ok = (p->Result_Nat_T_Sock == NULL ? false : true);
+ p->FinishedTick = Tick64();
+ p->Finished = true;
+
+ Set(p->FinishEvent);
+}
+
+// R-UDP (via NAT-T) connection thread
+void ConnectThreadForRUDP(THREAD *thread, void *param)
+{
+ SOCK *sock;
+ CONNECT_TCP_RUDP_PARAM *p = (CONNECT_TCP_RUDP_PARAM *)param;
+ if (thread == NULL || p == NULL)
+ {
+ return;
+ }
+
+ // Delay
+ if (p->Delay >= 1)
+ {
+ WaitEx(NULL, p->Delay, p->CancelFlag);
+ }
+
+ // Connecting process
+ sock = NewRUDPClientNatT(p->SvcName, &p->Ip, &p->NatT_ErrorCode, p->Timeout, p->CancelFlag, p->HintStr, p->TargetHostname);
+
+ p->Result_Nat_T_Sock = sock;
+ p->Ok = (p->Result_Nat_T_Sock == NULL ? false : true);
+ p->FinishedTick = Tick64();
+ p->Finished = true;
+
+ Set(p->FinishEvent);
+}
+
+// TCP connection
+SOCK *Connect(char *hostname, UINT port)
+{
+ return ConnectEx(hostname, port, 0);
+}
+SOCK *ConnectEx(char *hostname, UINT port, UINT timeout)
+{
+ return ConnectEx2(hostname, port, timeout, NULL);
+}
+SOCK *ConnectEx2(char *hostname, UINT port, UINT timeout, bool *cancel_flag)
+{
+ return ConnectEx3(hostname, port, timeout, cancel_flag, NULL, NULL, false, false, false);
+}
+SOCK *ConnectEx3(char *hostname, UINT port, UINT timeout, bool *cancel_flag, char *nat_t_svc_name, UINT *nat_t_error_code, bool try_start_ssl, bool ssl_no_tls, bool no_get_hostname)
+{
+ SOCK *sock;
+ SOCKET s;
+ struct linger ling;
+ IP ip4;
+ IP ip6;
+ bool true_flag = true;
+ bool false_flag = false;
+ char tmp[MAX_SIZE];
+ IP current_ip;
+ bool is_ipv6 = false;
+ bool dummy = false;
+ bool use_natt = false;
+ char hostname_original[MAX_SIZE];
+ char hint_str[MAX_SIZE];
+ bool force_use_natt = false;
+ UINT dummy_int = 0;
+ // Validate arguments
+ if (hostname == NULL || port == 0 || port >= 65536 || IsEmptyStr(hostname))
+ {
+ return NULL;
+ }
+ if (timeout == 0)
+ {
+ timeout = TIMEOUT_TCP_PORT_CHECK;
+ }
+ if (cancel_flag == NULL)
+ {
+ cancel_flag = &dummy;
+ }
+ if (nat_t_error_code == NULL)
+ {
+ nat_t_error_code = &dummy_int;
+ }
+
+ Zero(hint_str, sizeof(hint_str));
+ StrCpy(hostname_original, sizeof(hostname_original), hostname);
+
+ use_natt = (IsEmptyStr(nat_t_svc_name) ? false : true);
+
+ if (use_natt)
+ {
+ // In case of using NAT-T, split host name if the '/' is included in the host name
+ UINT i = SearchStrEx(hostname, "/", 0, false);
+
+ if (i == INFINITE)
+ {
+ // Not included
+ StrCpy(hostname_original, sizeof(hostname_original), hostname);
+ }
+ else
+ {
+ // Included
+ StrCpy(hostname_original, sizeof(hostname_original), hostname);
+ hostname_original[i] = 0;
+
+ // Force to use the NAT-T
+ force_use_natt = true;
+
+ // Copy the hint string
+ 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)
+ {
+ // Force not to use the NAT-T
+ force_use_natt = false;
+ use_natt = false;
+ }
+ }
+ }
+ else
+ {
+ StrCpy(hostname_original, sizeof(hostname_original), hostname);
+ }
+
+ Zero(¤t_ip, sizeof(current_ip));
+
+ Zero(&ip4, sizeof(ip4));
+ Zero(&ip6, sizeof(ip6));
+
+ // Forward resolution
+ if (GetIP46Ex(&ip4, &ip6, hostname_original, 0, cancel_flag) == false)
+ {
+ return NULL;
+ }
+
+ if (IsZeroIp(&ip4) == false && IsIPLocalHostOrMySelf(&ip4))
+ {
+ // NAT-T isn't used in the case of connection to localhost
+ force_use_natt = false;
+ use_natt = false;
+ }
+
+ s = INVALID_SOCKET;
+
+ // Attempt to connect with IPv4
+ if (IsZeroIp(&ip4) == false)
+ {
+ if (use_natt == false)
+ {
+ // Normal connection without using NAT-T
+ s = ConnectTimeoutIPv4(&ip4, port, timeout, cancel_flag);
+
+ if (s != INVALID_SOCKET)
+ {
+ Copy(¤t_ip, &ip4, sizeof(IP));
+ }
+ }
+ else if (force_use_natt)
+ {
+ // 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);
+
+ if (nat_t_sock != NULL)
+ {
+ StrCpy(nat_t_sock->UnderlayProtocol, sizeof(nat_t_sock->UnderlayProtocol), SOCK_UNDERLAY_NAT_T);
+ }
+
+ return nat_t_sock;
+ }
+ else
+ {
+ // Use the connections using NAT-T with normal TCP connection together
+ // (Use multiple threads to try to connect in four connection methods concurrently)
+ CONNECT_TCP_RUDP_PARAM p1, p2, p3, p4;
+ EVENT *finish_event;
+ THREAD *t1, *t2, *t3, *t4;
+ UINT64 start_tick = Tick64();
+ UINT64 giveup_for_all_tick = start_tick + (UINT64)SOCK_CONNECT_WAIT_FOR_ICMP_AND_DNS_AT_LEAST;
+ bool cancel_flag2 = false;
+ SOCK *cancel_sock = NULL;
+
+ finish_event = NewEvent();
+
+ Zero(&p1, sizeof(p1));
+ Zero(&p2, sizeof(p2));
+ Zero(&p3, sizeof(p3));
+ Zero(&p4, sizeof(p4));
+
+ // p1: TCP
+ StrCpy(p1.Hostname, sizeof(p1.Hostname), hostname_original);
+ Copy(&p1.Ip, &ip4, sizeof(IP));
+ p1.Port = port;
+ p1.Timeout = timeout;
+ p1.CancelFlag = &cancel_flag2;
+ p1.FinishEvent = finish_event;
+ p1.Tcp_TryStartSsl = try_start_ssl;
+ p1.Tcp_SslNoTls = ssl_no_tls;
+ p1.CancelLock = NewLock();
+
+ // p2: NAT-T
+ StrCpy(p2.Hostname, sizeof(p2.Hostname), hostname_original);
+ Copy(&p2.Ip, &ip4, sizeof(IP));
+ p2.Port = port;
+ p2.Timeout = timeout;
+ p2.CancelFlag = &cancel_flag2;
+ p2.FinishEvent = finish_event;
+
+ StrCpy(p2.HintStr, sizeof(p2.HintStr), hint_str);
+ StrCpy(p2.TargetHostname, sizeof(p2.TargetHostname), hostname);
+ StrCpy(p2.SvcName, sizeof(p2.SvcName), nat_t_svc_name);
+ p2.Delay = 30; // Delay by 30ms
+
+ // p3: over ICMP
+ StrCpy(p3.Hostname, sizeof(p3.Hostname), hostname_original);
+ Copy(&p3.Ip, &ip4, sizeof(IP));
+ p3.Port = port;
+ p3.Timeout = timeout;
+ p3.CancelFlag = &cancel_flag2;
+ p3.FinishEvent = finish_event;
+ StrCpy(p3.SvcName, sizeof(p3.SvcName), nat_t_svc_name);
+ p3.RUdpProtocol = RUDP_PROTOCOL_ICMP;
+ p3.Delay = 200; // Delay by 200ms
+
+ // p4: over DNS
+ StrCpy(p4.Hostname, sizeof(p4.Hostname), hostname_original);
+ Copy(&p4.Ip, &ip4, sizeof(IP));
+ p4.Port = port;
+ p4.Timeout = timeout;
+ p4.CancelFlag = &cancel_flag2;
+ p4.FinishEvent = finish_event;
+ StrCpy(p4.SvcName, sizeof(p4.SvcName), nat_t_svc_name);
+ p4.RUdpProtocol = RUDP_PROTOCOL_DNS;
+ p4.Delay = 100; // Delay by 100ms
+
+ t1 = NewThread(ConnectThreadForTcp, &p1);
+ t2 = NewThread(ConnectThreadForRUDP, &p2);
+ t4 = NewThread(ConnectThreadForOverDnsOrIcmp, &p4);
+ t3 = NewThread(ConnectThreadForOverDnsOrIcmp, &p3);
+
+ while (true)
+ {
+ UINT64 now = Tick64();
+
+ if (*cancel_flag)
+ {
+ // Cancel by the user
+ break;
+ }
+
+ if (p1.Finished && p2.Finished)
+ {
+ // Results for both the TCP and the NAT-T were confirmed
+ if (now >= giveup_for_all_tick)
+ {
+ // Wait at least minimum time until successful of the ICMP or the DNS
+ break;
+ }
+
+ if (p3.Ok || p4.Ok)
+ {
+ // Exit the loop immediately if any of the ICMP or the DNS is successful
+ break;
+ }
+ }
+
+ if (p1.Finished && p1.Ok)
+ {
+ // Have successfully connected by TCP
+ break;
+ }
+
+ if (p2.Finished && p2.Ok)
+ {
+ UINT p1_wait_time;
+ UINT64 tcp_giveup_tick;
+ UINT p2_spent_time;
+ // Have successfully connected by R-UDP
+ if (p1.Finished)
+ {
+ // Result of TCP is confirmed
+ break;
+ }
+
+ // Calculate the time takes to complete connection of R-UDP
+ p2_spent_time = (UINT)(p2.FinishedTick - start_tick);
+
+ // Decide the grace time for results of TCP until settled.
+ // The grace time is three times the duration of the R-UDP, and at least 250 milliseconds from the start,
+ // and up to 1500 milliseconds after the R-UDP results settled
+ p1_wait_time = p2_spent_time * 3;
+ p1_wait_time = MAX(p1_wait_time, 250);
+ //Debug("p2_spent_time = %u, p1_wait_time = %u\n", p2_spent_time, p1_wait_time);
+
+ tcp_giveup_tick = start_tick + (UINT64)p1_wait_time;
+ tcp_giveup_tick = MIN(tcp_giveup_tick, (p2.FinishedTick + 1500ULL));
+
+ if (now >= tcp_giveup_tick)
+ {
+ // Result of the TCP is uncertain, but give up
+ break;
+ }
+ }
+
+ Wait(finish_event, 25);
+ }
+
+ cancel_flag2 = true;
+
+ Lock(p1.CancelLock);
+ {
+ if (p1.CancelDisconnectSock != NULL)
+ {
+ cancel_sock = p1.CancelDisconnectSock;
+
+ AddRef(cancel_sock->ref);
+ }
+ }
+ Unlock(p1.CancelLock);
+
+ if (cancel_sock != NULL)
+ {
+ Disconnect(cancel_sock);
+ ReleaseSock(cancel_sock);
+ }
+
+ WaitThread(t1, INFINITE);
+ WaitThread(t2, INFINITE);
+ WaitThread(t3, INFINITE);
+ WaitThread(t4, INFINITE);
+ ReleaseThread(t1);
+ ReleaseThread(t2);
+ ReleaseThread(t3);
+ ReleaseThread(t4);
+ ReleaseEvent(finish_event);
+
+ DeleteLock(p1.CancelLock);
+
+ if (*cancel_flag)
+ {
+ // Abandon all the results because the user canceled
+ Disconnect(p1.Result_Nat_T_Sock);
+ ReleaseSock(p1.Result_Nat_T_Sock);
+ Disconnect(p2.Result_Nat_T_Sock);
+ ReleaseSock(p2.Result_Nat_T_Sock);
+ Disconnect(p3.Result_Nat_T_Sock);
+ ReleaseSock(p3.Result_Nat_T_Sock);
+ Disconnect(p4.Result_Nat_T_Sock);
+ ReleaseSock(p4.Result_Nat_T_Sock);
+
+ return NULL;
+ }
+
+ if (p1.Ok)
+ {
+ char hostname[MAX_SIZE];
+
+ // Use the results of the TCP
+ // Dispose other results
+ Disconnect(p2.Result_Nat_T_Sock);
+ ReleaseSock(p2.Result_Nat_T_Sock);
+ Disconnect(p3.Result_Nat_T_Sock);
+ ReleaseSock(p3.Result_Nat_T_Sock);
+ Disconnect(p4.Result_Nat_T_Sock);
+ ReleaseSock(p4.Result_Nat_T_Sock);
+
+ if (GetHostName(hostname, sizeof(hostname), &ip4))
+ {
+ Free(p1.Result_Tcp_Sock->RemoteHostname);
+ p1.Result_Tcp_Sock->RemoteHostname = CopyStr(hostname);
+ }
+
+ return p1.Result_Tcp_Sock;
+ }
+ else if (p2.Ok)
+ {
+ // Use the results of the R-UDP
+ // Dispose other results
+ Disconnect(p3.Result_Nat_T_Sock);
+ ReleaseSock(p3.Result_Nat_T_Sock);
+ Disconnect(p4.Result_Nat_T_Sock);
+ ReleaseSock(p4.Result_Nat_T_Sock);
+
+ StrCpy(p2.Result_Nat_T_Sock->UnderlayProtocol, sizeof(p2.Result_Nat_T_Sock->UnderlayProtocol),
+ SOCK_UNDERLAY_NAT_T);
+
+ return p2.Result_Nat_T_Sock;
+ }
+ else if (p4.Ok)
+ {
+ // Use this if over-DNS success
+ // Dispose other results
+ Disconnect(p3.Result_Nat_T_Sock);
+ ReleaseSock(p3.Result_Nat_T_Sock);
+
+ StrCpy(p4.Result_Nat_T_Sock->UnderlayProtocol, sizeof(p4.Result_Nat_T_Sock->UnderlayProtocol),
+ SOCK_UNDERLAY_DNS);
+
+ return p4.Result_Nat_T_Sock;
+ }
+ else if (p3.Ok)
+ {
+ // Use this if over ICMP success
+ StrCpy(p3.Result_Nat_T_Sock->UnderlayProtocol, sizeof(p3.Result_Nat_T_Sock->UnderlayProtocol),
+ SOCK_UNDERLAY_ICMP);
+
+ return p3.Result_Nat_T_Sock;
+ }
+ else
+ {
+ // Continue the process if all trials failed
+ *nat_t_error_code = p2.NatT_ErrorCode;
+ }
+ }
+ }
+
+ // Attempt to connect with IPv6
+ if (s == INVALID_SOCKET && IsZeroIp(&ip6) == false)
+ {
+ struct sockaddr_in6 sockaddr6;
+ struct in6_addr addr6;
+
+ Zero(&sockaddr6, sizeof(sockaddr6));
+ Zero(&addr6, sizeof(addr6));
+
+ // Generation of the sockaddr_in6
+ IPToInAddr6(&addr6, &ip6);
+ sockaddr6.sin6_port = htons((USHORT)port);
+ sockaddr6.sin6_family = AF_INET6;
+ sockaddr6.sin6_scope_id = ip6.ipv6_scope_id;
+ Copy(&sockaddr6.sin6_addr, &addr6, sizeof(addr6));
+
+ // Socket creation
+ s = socket(AF_INET6, SOCK_STREAM, 0);
+ if (s != INVALID_SOCKET)
+ {
+ // Connection
+ if (connect_timeout(s, (struct sockaddr *)&sockaddr6, sizeof(struct sockaddr_in6), timeout, cancel_flag) != 0)
+ {
+ // Connection failure
+ closesocket(s);
+ s = INVALID_SOCKET;
+ }
+ else
+ {
+ Copy(¤t_ip, &ip6, sizeof(IP));
+
+ is_ipv6 = true;
+ }
+ }
+ }
+
+ if (s == INVALID_SOCKET)
+ {
+ // Connection fails on both of IPv4, IPv6
+ return NULL;
+ }
+
+ // Creating a SOCK
+ sock = NewSock();
+ sock->socket = s;
+ sock->Type = SOCK_TCP;
+ sock->ServerMode = false;
+
+ StrCpy(sock->UnderlayProtocol, sizeof(sock->UnderlayProtocol),
+ (is_ipv6 ? SOCK_UNDERLAY_NATIVE_V6 : SOCK_UNDERLAY_NATIVE_V4));
+
+ // Host name resolution
+ if (no_get_hostname || (GetHostName(tmp, sizeof(tmp), ¤t_ip) == false))
+ {
+ StrCpy(tmp, sizeof(tmp), hostname_original);
+ }
+
+ //Debug("PTR: %s\n", tmp);
+
+ sock->RemoteHostname = CopyStr(tmp);
+
+// Debug("new socket: %u\n", s);
+
+ Zero(&ling, sizeof(ling));
+ // Forced disconnection flag
+#ifdef SO_DONTLINGER
+ setsockopt(sock->socket, SOL_SOCKET, SO_DONTLINGER, (char *)&true_flag, sizeof(bool));
+#else // SO_DONTLINGER
+ 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));
+
+ // Configuring TCP options
+ setsockopt(sock->socket, IPPROTO_TCP, TCP_NODELAY, (char *)&true_flag, sizeof(bool));
+
+ // Initialization of the time-out value
+ SetTimeout(sock, TIMEOUT_INFINITE);
+
+ // Get the socket information
+ QuerySocketInformation(sock);
+
+ if (IsZeroIp(&sock->LocalIP) == false && IsLocalHostIP(&sock->LocalIP) == false)
+ {
+ IP current_ip;
+
+ if (GetCurrentGlobalIP(¤t_ip, is_ipv6) == false)
+ {
+ SetCurrentGlobalIP(&sock->LocalIP, is_ipv6);
+ }
+ }
+
+ sock->Connected = true;
+ sock->AsyncMode = false;
+ sock->SecureMode = false;
+ sock->IPv6 = is_ipv6;
+
+ return sock;
+}
+
+// Maximize the I/O buffer size of the socket
+void SetSocketSendRecvBufferSize(SOCKET s, UINT size)
+{
+ int value = (int)size;
+ // Validate arguments
+ if (s == INVALID_SOCKET)
+ {
+ return;
+ }
+
+ setsockopt(s, SOL_SOCKET, SO_RCVBUF, (char *)&value, sizeof(int));
+ setsockopt(s, SOL_SOCKET, SO_SNDBUF, (char *)&value, sizeof(int));
+}
+
+// Get the buffer size of the socket
+UINT GetSocketBufferSize(SOCKET s, bool send)
+{
+ int value = 0;
+ int len = sizeof(int);
+ // Validate arguments
+ if (s == INVALID_SOCKET)
+ {
+ return 0;
+ }
+
+ if (getsockopt(s, SOL_SOCKET, (send ? SO_SNDBUF : SO_RCVBUF), (char *)&value, &len) != 0)
+ {
+ return 0;
+ }
+
+ return value;
+}
+
+// Setting the buffer size of the socket
+bool SetSocketBufferSize(SOCKET s, bool send, UINT size)
+{
+ int value = (int)size;
+ // Validate arguments
+ if (s == INVALID_SOCKET)
+ {
+ return false;
+ }
+
+ if (setsockopt(s, SOL_SOCKET, (send ? SO_SNDBUF : SO_RCVBUF), (char *)&value, sizeof(int)) != 0)
+ {
+ return false;
+ }
+
+ return true;
+}
+UINT SetSocketBufferSizeWithBestEffort(SOCKET s, bool send, UINT size)
+{
+ // Validate arguments
+ if (s == INVALID_SOCKET)
+ {
+ return 0;
+ }
+
+ while (true)
+ {
+ if (SetSocketBufferSize(s, send, size))
+ {
+ return size;
+ }
+
+ size = (UINT)((double)size / 1.5);
+
+ if (size <= 32767)
+ {
+ return 0;
+ }
+ }
+}
+
+// Initialize the buffer size of the UDP socket
+void InitUdpSocketBufferSize(SOCKET s)
+{
+ SetSocketBufferSizeWithBestEffort(s, true, UDP_MAX_BUFFER_SIZE);
+ SetSocketBufferSizeWithBestEffort(s, false, UDP_MAX_BUFFER_SIZE);
+}
+
+// Get the socket information
+void QuerySocketInformation(SOCK *sock)
+{
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return;
+ }
+
+ Lock(sock->lock);
+ {
+ struct sockaddr_in6 sockaddr6;
+ struct in6_addr *addr6;
+ int size;
+ DWORD dw;
+ UINT opt_value = 0;
+
+ if (sock->Type == SOCK_TCP)
+ {
+ // Get the information of the remote host
+ size = sizeof(sockaddr6);
+ if (getpeername(sock->socket, (struct sockaddr *)&sockaddr6, (int *)&size) == 0)
+ {
+ if (size >= sizeof(struct sockaddr_in6))
+ {
+ sock->RemotePort = (UINT)ntohs(sockaddr6.sin6_port);
+ addr6 = &sockaddr6.sin6_addr;
+ InAddrToIP6(&sock->RemoteIP, addr6);
+ sock->RemoteIP.ipv6_scope_id = sockaddr6.sin6_scope_id;
+ }
+ else
+ {
+ struct sockaddr_in *sockaddr;
+ struct in_addr *addr;
+
+ sockaddr = (struct sockaddr_in *)&sockaddr6;
+ sock->RemotePort = (UINT)ntohs(sockaddr->sin_port);
+ addr = &sockaddr->sin_addr;
+ InAddrToIP(&sock->RemoteIP, addr);
+ }
+ }
+ }
+
+ // Get the local host information
+ size = sizeof(sockaddr6);
+ if (getsockname(sock->socket, (struct sockaddr *)&sockaddr6, (int *)&size) == 0)
+ {
+ if (size >= sizeof(struct sockaddr_in6))
+ {
+ sock->LocalPort = (UINT)ntohs(sockaddr6.sin6_port);
+ addr6 = &sockaddr6.sin6_addr;
+ InAddrToIP6(&sock->LocalIP, addr6);
+ sock->LocalIP.ipv6_scope_id = sockaddr6.sin6_scope_id;
+ }
+ else
+ {
+ struct sockaddr_in *sockaddr;
+ struct in_addr *addr;
+
+ sockaddr = (struct sockaddr_in *)&sockaddr6;
+ sock->LocalPort = (UINT)ntohs(sockaddr->sin_port);
+ addr = &sockaddr->sin_addr;
+ InAddrToIP(&sock->LocalIP, addr);
+ }
+ }
+
+ if (sock->IsRawSocket)
+ {
+ sock->LocalPort = sock->RemotePort = MAKE_SPECIAL_PORT(sock->RawSocketIPProtocol);
+ }
+
+ if (sock->Type == SOCK_UDP)
+ {
+ sock->UdpMaxMsgSize = UDP_MAX_MSG_SIZE_DEFAULT;
+
+#ifdef OS_WIN32
+ if (true)
+ {
+ // Get the buffer size that can be transmitted and received at once
+ UINT max_value = 0;
+ int len = sizeof(UINT);
+
+ if (getsockopt(sock->socket, SOL_SOCKET, SO_MAX_MSG_SIZE, (char *)&max_value, &len) == 0)
+ {
+ sock->UdpMaxMsgSize = max_value;
+ }
+ }
+#endif // OS_WIN32
+ }
+
+ if (sock->IPv6)
+ {
+#ifdef IPV6_UNICAST_HOPS
+ opt_value = IPV6_UNICAST_HOPS;
+#endif // IPV6_UNICAST_HOPS
+ }
+ else
+ {
+#ifdef IP_TTL
+ opt_value = IP_TTL;
+#endif // IP_TTL
+ }
+
+ // 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)
+ {
+ sock->IsTtlSupported = false;
+ }
+ else
+ {
+ sock->IsTtlSupported = true;
+ sock->CurrentTtl = dw;
+ }
+ }
+ Unlock(sock->lock);
+}
+
+// Setting the TTL value
+bool SetTtl(SOCK *sock, UINT ttl)
+{
+ DWORD dw;
+ int size;
+ UINT opt_value = 0;
+ // Validate arguments
+ if (sock == NULL)
+ {
+ return false;
+ }
+
+ if (sock->IsTtlSupported == false)
+ {
+ return false;
+ }
+
+ if (sock->CurrentTtl == ttl)
+ {
+ return true;
+ }
+
+ dw = ttl;
+ size = sizeof(DWORD);
+
+ if (sock->IPv6)
+ {
+#ifdef IPV6_UNICAST_HOPS
+ opt_value = IPV6_UNICAST_HOPS;
+#endif // IPV6_UNICAST_HOPS
+ }
+ else
+ {
+#ifdef IP_TTL
+ opt_value = IP_TTL;
+#endif // IP_TTL
+ }
+
+ if (opt_value == 0 ||
+ setsockopt(sock->socket, (sock->IPv6 ? IPPROTO_IPV6 : IPPROTO_IP), opt_value, (char *)&dw, size) == false)
+ {
+ return false;
+ }
+
+ sock->CurrentTtl = ttl;
+
+ return true;
+}
+
+// Release of the socket
+void ReleaseSock(SOCK *s)
+{
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+ if (Release(s->ref) == 0)
+ {
+ if (s->ListenMode == false && s->ServerMode)
+ {
+ Print("");
+ }
+ CleanupSock(s);
+ }
+}
+
+// Clean-up of the socket
+void CleanupSock(SOCK *s)
+{
+ // Validate arguments
+ if (s == NULL)
+ {
+ return;
+ }
+
+// {Debug("CleanupSock: Disconnect() Called: %s %u\n", __FILE__, __LINE__);Disconnect(s);}
+ Disconnect(s);
+
+ if (s->InProcAcceptQueue != NULL)
+ {
+ while (true)
+ {
+ SOCK *ss = GetNext(s->InProcAcceptQueue);
+ if (ss == NULL)
+ {
+ break;
+ }
+
+ Disconnect(ss);
+ ReleaseSock(ss);
+ }
+
+ ReleaseQueue(s->InProcAcceptQueue);
+ }
+
+ if (s->InProcAcceptEvent != NULL)
+ {
+ ReleaseEvent(s->InProcAcceptEvent);
+ }
+
+ if (s->ReverseAcceptQueue != NULL)
+ {
+ while (true)
+ {
+ SOCK *ss = GetNext(s->ReverseAcceptQueue);
+ if (ss == NULL)
+ {
+ break;
+ }
+
+ Disconnect(ss);
+ ReleaseSock(ss);
+ }
+
+ ReleaseQueue(s->ReverseAcceptQueue);
+ }
+
+ if (s->ReverseAcceptEvent != NULL)
+ {
+ ReleaseEvent(s->ReverseAcceptEvent);
+ }
+
+ if (s->SendTube != NULL)
+ {
+ TubeDisconnect(s->SendTube);
+ ReleaseTube(s->SendTube);
+ }
+
+ if (s->RecvTube != NULL)
+ {
+ TubeDisconnect(s->RecvTube);
+ ReleaseTube(s->RecvTube);
+ }
+
+ if (s->BulkRecvTube != NULL)
+ {
+ TubeDisconnect(s->BulkRecvTube);
+ ReleaseTube(s->BulkRecvTube);
+ }
+
+ if (s->BulkSendTube != NULL)
+ {
+ TubeDisconnect(s->BulkSendTube);
+ ReleaseTube(s->BulkSendTube);
+ }
+
+ if (s->BulkSendKey != NULL)
+ {
+ ReleaseSharedBuffer(s->BulkSendKey);
+ }
+
+ if (s->BulkRecvKey != NULL)
+ {
+ ReleaseSharedBuffer(s->BulkRecvKey);
+ }
+
+ if (s->InProcRecvFifo != NULL)
+ {
+ ReleaseFifo(s->InProcRecvFifo);
+ }
+
+ if (s->R_UDP_Stack != NULL)
+ {
+ FreeRUDP(s->R_UDP_Stack);
+ }
+
+#ifdef OS_WIN32
+ Win32FreeAsyncSocket(s);
+#else // OS_WIN32
+ UnixFreeAsyncSocket(s);
+#endif // OS_WIN32
+
+ FreeBuf(s->SendBuf);
+ if (s->socket != INVALID_SOCKET)
+ {
+#ifdef OS_WIN32
+ closesocket(s->socket);
+#else // OS_WIN32
+ close(s->socket);
+#endif // OS_WIN32
+ }
+ Free(s->RemoteHostname);
+
+#ifdef OS_WIN32
+ if (s->hAcceptEvent != NULL)
+ {
+ CloseHandle(s->hAcceptEvent);
+ }
+#endif // OS_WIN32
+
+ Free(s->WaitToUseCipher);
+ DeleteLock(s->lock);
+ DeleteLock(s->ssl_lock);
+ DeleteLock(s->disconnect_lock);
+
+ Dec(num_tcp_connections);
+
+ Free(s);
+}
+
+// Creating a new socket
+SOCK *NewSock()
+{
+ SOCK *s = ZeroMallocFast(sizeof(SOCK));
+
+ s->ref = NewRef();
+ s->lock = NewLock();
+ s->SendBuf = NewBuf();
+ s->socket = INVALID_SOCKET;
+ s->ssl_lock = NewLock();
+ s->disconnect_lock = NewLock();
+
+ Inc(num_tcp_connections);
+
+ return s;
+}
+
+// Convert the IP to UINT
+UINT IPToUINT(IP *ip)
+{
+ UCHAR *b;
+ UINT i, value = 0;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return 0;
+ }
+
+ b = (UCHAR *)&value;
+ for (i = 0;i < 4;i++)
+ {
+ b[i] = ip->addr[i];
+ }
+
+ return value;
+}
+
+// Convert UINT to IP
+void UINTToIP(IP *ip, UINT value)
+{
+ UCHAR *b;
+ UINT i;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ ZeroIP4(ip);
+
+ b = (UCHAR *)&value;
+ for (i = 0;i < 4;i++)
+ {
+ ip->addr[i] = b[i];
+ }
+}
+
+// Get the host name of the computer
+void GetMachineHostName(char *name, UINT size)
+{
+ char tmp[MAX_SIZE];
+ UINT i, len;
+ // Validate arguments
+ if (name == NULL)
+ {
+ return;
+ }
+
+ GetMachineName(tmp, sizeof(tmp));
+
+ len = StrLen(tmp);
+ for (i = 0;i < len;i++)
+ {
+ if (tmp[i] == '.')
+ {
+ tmp[i] = 0;
+ }
+ }
+
+ ConvertSafeFileName(name, size, tmp);
+}
+
+// Get the IP address of this computer
+void GetMachineIp(IP *ip)
+{
+ char tmp[MAX_SIZE];
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ Zero(ip, sizeof(IP));
+ SetIP(ip, 127, 0, 0, 1);
+
+ GetMachineName(tmp, sizeof(tmp));
+ GetIP(ip, tmp);
+}
+
+// Get the computer name from 'hosts'
+bool GetMachineNameFromHosts(char *name, UINT size)
+{
+ bool ret = false;
+ char *s;
+ BUF *b;
+ // Validate arguments
+ if (name == NULL)
+ {
+ return false;
+ }
+
+ b = ReadDump("/etc/hosts");
+ if (b == NULL)
+ {
+ return false;
+ }
+
+ while (true)
+ {
+ s = CfgReadNextLine(b);
+ if (s == NULL)
+ {
+ break;
+ }
+ else
+ {
+ TOKEN_LIST *t = ParseToken(s, " \t");
+
+ if (t != NULL)
+ {
+ if (t->NumTokens >= 2)
+ {
+ if (StrCmpi(t->Token[0], "127.0.0.1") == 0)
+ {
+ UINT i;
+
+ for (i = 1;i < t->NumTokens;i++)
+ {
+ if (StartWith(t->Token[i], "localhost") == false)
+ {
+ StrCpy(name, size, t->Token[i]);
+ ret = true;
+ }
+ }
+ }
+ }
+ }
+ FreeToken(t);
+ }
+
+ Free(s);
+ }
+
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Get the computer name of this computer
+void GetMachineName(char *name, UINT size)
+{
+ GetMachineNameEx(name, size, false);
+}
+void GetMachineNameEx(char *name, UINT size, bool no_load_hosts)
+{
+ static char name_cache[MAX_SIZE];
+ static bool name_cached = false;
+ char tmp[MAX_SIZE];
+ char tmp2[MAX_SIZE];
+ // Validate arguments
+ if (name == NULL)
+ {
+ return;
+ }
+
+ Lock(machine_name_lock);
+ {
+ if (name_cached != false)
+ {
+ StrCpy(name, size, name_cache);
+ Unlock(machine_name_lock);
+ return;
+ }
+ ClearStr(tmp, sizeof(tmp));
+ if (gethostname(tmp, MAX_SIZE) != 0)
+ {
+ StrCpy(name, size, "Unknown");
+ Unlock(machine_name_lock);
+ return;
+ }
+ ClearStr(name, size);
+ StrCpy(name, size, tmp);
+ if (IsEmptyStr(name) || StartWith(name, "localhost"))
+ {
+#ifdef OS_WIN32
+ ClearStr(name, size);
+ MsGetComputerName(name, size);
+#endif // OS_WIN32
+ }
+ if (IsEmptyStr(name) || StartWith(name, "localhost"))
+ {
+ if (no_load_hosts == false && OS_IS_UNIX(GetOsInfo()->OsType))
+ {
+ if (GetMachineNameFromHosts(tmp2, sizeof(tmp2)))
+ {
+ StrCpy(name, sizeof(name), tmp2);
+ }
+ }
+ }
+
+ StrCpy(name_cache, sizeof(name_cache), name);
+ name_cached = true;
+ }
+ Unlock(machine_name_lock);
+}
+
+// Host name acquisition thread
+void GetHostNameThread(THREAD *t, void *p)
+{
+ IP *ip;
+ char hostname[256];
+ // Validate arguments
+ if (t == NULL || p == NULL)
+ {
+ return;
+ }
+
+ ip = (IP *)p;
+
+ AddWaitThread(t);
+
+ NoticeThreadInit(t);
+
+ if (GetHostNameInner(hostname, sizeof(hostname), ip))
+ {
+ AddHostCache(ip, hostname);
+ }
+
+ Free(ip);
+
+ DelWaitThread(t);
+}
+
+// Get the host name
+bool GetHostName(char *hostname, UINT size, IP *ip)
+{
+ THREAD *t;
+ IP *p_ip;
+ bool ret;
+ // Validate arguments
+ if (hostname == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ if (GetHostCache(hostname, size, ip))
+ {
+ if (IsEmptyStr(hostname) == false)
+ {
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+
+ p_ip = ZeroMalloc(sizeof(IP));
+ Copy(p_ip, ip, sizeof(IP));
+
+ t = NewThread(GetHostNameThread, p_ip);
+
+ WaitThreadInit(t);
+
+ WaitThread(t, TIMEOUT_HOSTNAME);
+
+ ReleaseThread(t);
+
+ ret = GetHostCache(hostname, size, ip);
+ if (ret == false)
+ {
+ if (IsIP4(ip))
+ {
+ ret = GetNetBiosName(hostname, size, ip);
+ if (ret)
+ {
+ AddHostCache(ip, hostname);
+ }
+ }
+ }
+ else
+ {
+ if (IsEmptyStr(hostname))
+ {
+ ret = false;
+ }
+ }
+ if (ret == false)
+ {
+ AddHostCache(ip, "");
+ StrCpy(hostname, size, "");
+ }
+
+ return ret;
+}
+
+// Perform a DNS reverse query
+bool GetHostNameInner(char *hostname, UINT size, IP *ip)
+{
+ struct in_addr addr;
+ struct sockaddr_in sa;
+ char tmp[MAX_SIZE];
+ char ip_str[64];
+ // Validate arguments
+ if (hostname == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ if (IsIP6(ip))
+ {
+ return GetHostNameInner6(hostname, size, ip);
+ }
+
+ // Reverse resolution
+ IPToInAddr(&addr, ip);
+ Zero(&sa, sizeof(sa));
+ sa.sin_family = AF_INET;
+
+#if defined(UNIX_BSD) || defined(UNIX_MACOS)
+ sa.sin_len = INET_ADDRSTRLEN;
+#endif // UNIX_BSD || UNIX_MACOS
+
+ Copy(&sa.sin_addr, &addr, sizeof(struct in_addr));
+ sa.sin_port = 0;
+
+ if (getnameinfo((struct sockaddr *)&sa, sizeof(sa), tmp, sizeof(tmp), NULL, 0, 0) != 0)
+ {
+ return false;
+ }
+
+ IPToStr(ip_str, sizeof(ip_str), ip);
+
+ if (StrCmpi(tmp, ip_str) == 0)
+ {
+ return false;
+ }
+
+ if (IsEmptyStr(tmp))
+ {
+ return false;
+ }
+
+ StrCpy(hostname, size, tmp);
+
+ return true;
+}
+bool GetHostNameInner6(char *hostname, UINT size, IP *ip)
+{
+ struct in6_addr addr;
+ struct sockaddr_in6 sa;
+ char tmp[MAX_SIZE];
+ char ip_str[256];
+ // Validate arguments
+ if (hostname == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ // Reverse resolution
+ IPToInAddr6(&addr, ip);
+ Zero(&sa, sizeof(sa));
+ sa.sin6_family = AF_INET6;
+
+#if defined(UNIX_BSD) || defined(UNIX_MACOS)
+ sa.sin6_len = INET6_ADDRSTRLEN;
+#endif // UNIX_BSD || UNIX_MACOS
+
+ Copy(&sa.sin6_addr, &addr, sizeof(struct in6_addr));
+ sa.sin6_port = 0;
+
+ if (getnameinfo((struct sockaddr *)&sa, sizeof(sa), tmp, sizeof(tmp), NULL, 0, 0) != 0)
+ {
+ return false;
+ }
+
+ IPToStr(ip_str, sizeof(ip_str), ip);
+
+ if (StrCmpi(tmp, ip_str) == 0)
+ {
+ return false;
+ }
+
+ if (IsEmptyStr(tmp))
+ {
+ return false;
+ }
+
+ StrCpy(hostname, size, tmp);
+
+ return true;
+}
+
+#define NUM_NBT_QUERYS_SEND 3
+
+// Get the NetBIOS name of the machine from the IP address
+bool GetNetBiosName(char *name, UINT size, IP *ip)
+{
+ SOCK *s;
+ UINT i, j;
+ bool flag = false;
+ bool ok = false;
+ NBTREQUEST req;
+ UCHAR buf[1024];
+ USHORT tran_id[NUM_NBT_QUERYS_SEND];
+ UINT64 timeout_tick;
+ // Validate arguments
+ if (name == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ IPToStr(name, size, ip);
+
+ for (i = 0;i < NUM_NBT_QUERYS_SEND;i++)
+ {
+ tran_id[i] = Rand16();
+ }
+
+ s = NewUDP(0);
+ if (s == NULL)
+ {
+ return false;
+ }
+
+ for (j = 0;j < NUM_NBT_QUERYS_SEND;j++)
+ {
+ Zero(&req, sizeof(req));
+ req.TransactionId = Endian16(tran_id[j]);
+ req.NumQuestions = Endian16(1);
+ req.Query[0] = 0x20;
+ req.Query[1] = 0x43;
+ req.Query[2] = 0x4b;
+ for (i = 3;i <= 32;i++)
+ {
+ req.Query[i] = 0x41;
+ }
+ req.Query[35] = 0x21;
+ req.Query[37] = 0x01;
+
+ if (SendTo(s, ip, 137, &req, sizeof(req)) == 0)
+ {
+ ReleaseSock(s);
+ return false;
+ }
+ }
+
+ timeout_tick = Tick64() + (UINT64)TIMEOUT_NETBIOS_HOSTNAME;
+
+ while (1)
+ {
+ UINT ret;
+ IP src_ip;
+ UINT src_port;
+ SOCKSET set;
+ if (Tick64() >= timeout_tick)
+ {
+ break;
+ }
+ InitSockSet(&set);
+ AddSockSet(&set, s);
+ Select(&set, 100, NULL, NULL);
+
+ if (flag == false)
+ {
+ flag = true;
+ }
+ else
+ {
+ SleepThread(10);
+ }
+
+ ret = RecvFrom(s, &src_ip, &src_port, buf, sizeof(buf));
+
+ if (ret == SOCK_LATER)
+ {
+ continue;
+ }
+ else if (ret == 0)
+ {
+ break;
+ }
+ else
+ {
+ if (ret >= sizeof(NBTRESPONSE))
+ {
+ NBTRESPONSE *r = (NBTRESPONSE *)buf;
+ bool b = false;
+ UINT i;
+ USHORT id = Endian16(r->TransactionId);
+ for (i = 0;i < NUM_NBT_QUERYS_SEND;i++)
+ {
+ if (id == tran_id[i])
+ {
+ b = true;
+ break;
+ }
+ }
+ if (b)
+ {
+ if (r->Flags != 0 && r->NumQuestions == 0 && r->AnswerRRs >= 1)
+ {
+ if (r->Response[0] == 0x20 && r->Response[1] == 0x43 &&
+ r->Response[2] == 0x4b)
+ {
+ if (r->Response[34] == 0x00 && r->Response[35] == 0x21 &&
+ r->Response[36] == 0x00 && r->Response[37] == 0x01)
+ {
+ char *a = (char *)(&r->Response[45]);
+ if (StrCheckLen(a, 15))
+ {
+ if (IsEmptyStr(a) == false)
+ {
+ StrCpy(name, size, a);
+ Trim(name);
+ ok = true;
+ }
+ else
+ {
+ ok = false;
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ ReleaseSock(s);
+ return ok;
+}
+
+// Set the IP address
+void SetIP(IP *ip, UCHAR a1, UCHAR a2, UCHAR a3, UCHAR a4)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ Zero(ip, sizeof(IP));
+ ip->addr[0] = a1;
+ ip->addr[1] = a2;
+ ip->addr[2] = a3;
+ ip->addr[3] = a4;
+}
+UINT SetIP32(UCHAR a1, UCHAR a2, UCHAR a3, UCHAR a4)
+{
+ IP ip;
+
+ Zero(&ip, sizeof(ip));
+ SetIP(&ip, a1, a2, a3, a4);
+
+ return IPToUINT(&ip);
+}
+
+// Get either of v4 and v6 results with a DNS forward lookup (The IPv4 precedes in the case of both results)
+bool GetIP46Any4(IP *ip, char *hostname)
+{
+ IP ip4, ip6;
+ bool b = false;
+ // Validate arguments
+ if (ip == NULL || hostname == NULL)
+ {
+ return false;
+ }
+
+ if (GetIP46(&ip4, &ip6, hostname) == false)
+ {
+ return false;
+ }
+
+ if (IsZeroIp(&ip6) == false)
+ {
+ Copy(ip, &ip6, sizeof(IP));
+
+ b = true;
+ }
+
+ if (IsZeroIp(&ip4) == false)
+ {
+ Copy(ip, &ip4, sizeof(IP));
+
+ b = true;
+ }
+
+ return b;
+}
+
+// Get either of v4 and v6 results with a DNS forward lookup (The IPv6 precedes in the case of both)
+bool GetIP46Any6(IP *ip, char *hostname)
+{
+ IP ip4, ip6;
+ bool b = false;
+ // Validate arguments
+ if (ip == NULL || hostname == NULL)
+ {
+ return false;
+ }
+
+ if (GetIP46(&ip4, &ip6, hostname) == false)
+ {
+ return false;
+ }
+
+ if (IsZeroIp(&ip4) == false)
+ {
+ Copy(ip, &ip4, sizeof(IP));
+
+ b = true;
+ }
+
+ if (IsZeroIp(&ip6) == false)
+ {
+ Copy(ip, &ip6, sizeof(IP));
+
+ b = true;
+ }
+
+ return b;
+}
+
+// Obtain in both v4 and v6 results with a DNS forward lookup
+bool GetIP46(IP *ip4, IP *ip6, char *hostname)
+{
+ return GetIP46Ex(ip4, ip6, hostname, 0, NULL);
+}
+bool GetIP46Ex(IP *ip4, IP *ip6, char *hostname, UINT timeout, bool *cancel)
+{
+ IP a, b;
+ bool ok_a, ok_b;
+ // Validate arguments
+ if (ip4 == NULL || ip6 == NULL || hostname == NULL)
+ {
+ return false;
+ }
+
+ ZeroIP4(ip4);
+ ZeroIP6(ip6);
+
+ ok_a = ok_b = false;
+
+ if (GetIP6Ex(&a, hostname, timeout, cancel))
+ {
+ ok_a = true;
+ }
+
+ if (GetIP4Ex(&b, hostname, timeout, cancel))
+ {
+ ok_b = true;
+ }
+
+ if (ok_a)
+ {
+ if (IsIP4(&a))
+ {
+ Copy(ip4, &a, sizeof(IP));
+ }
+ }
+ if (ok_b)
+ {
+ if (IsIP4(&b))
+ {
+ Copy(ip4, &b, sizeof(IP));
+ }
+
+ if (IsIP6(&b))
+ {
+ Copy(ip6, &b, sizeof(IP));
+ }
+ }
+ if (ok_a)
+ {
+ if (IsIP6(&a))
+ {
+ Copy(ip6, &a, sizeof(IP));
+ }
+ }
+
+ if (IsZeroIp(ip4) && IsZeroIp(ip6))
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Clean-up of the parameters for GetIP thread
+void CleanupGetIPThreadParam(GETIP_THREAD_PARAM *p)
+{
+ // Validate arguments
+ if (p == NULL)
+ {
+ return;
+ }
+
+ Free(p);
+}
+
+// Release of the parameters of the GetIP for thread
+void ReleaseGetIPThreadParam(GETIP_THREAD_PARAM *p)
+{
+ // Validate arguments
+ if (p == NULL)
+ {
+ return;
+ }
+
+ if (Release(p->Ref) == 0)
+ {
+ CleanupGetIPThreadParam(p);
+ }
+}
+
+// Thread to perform to query the DNS forward lookup (with timeout)
+void GetIP4Ex6ExThread(THREAD *t, void *param)
+{
+ GETIP_THREAD_PARAM *p;
+ // Validate arguments
+ if (t == NULL || param == NULL)
+ {
+ return;
+ }
+
+ p = (GETIP_THREAD_PARAM *)param;
+
+ AddRef(p->Ref);
+
+ NoticeThreadInit(t);
+
+ AddWaitThread(t);
+
+ // Execution of resolution
+ if (p->IPv6 == false)
+ {
+ // IPv4
+ p->Ok = GetIP4Inner(&p->Ip, p->HostName);
+ }
+ else
+ {
+ // IPv6
+ p->Ok = GetIP6Inner(&p->Ip, p->HostName);
+ }
+
+ ReleaseGetIPThreadParam(p);
+
+ DelWaitThread(t);
+}
+
+// Perform a forward DNS query (with timeout)
+bool GetIP4Ex6Ex(IP *ip, char *hostname_arg, UINT timeout, bool ipv6, bool *cancel)
+{
+ return GetIP4Ex6Ex2(ip, hostname_arg, timeout, ipv6, cancel, false);
+}
+bool GetIP4Ex6Ex2(IP *ip, char *hostname_arg, UINT timeout, bool ipv6, bool *cancel, bool only_direct_dns)
+{
+ GETIP_THREAD_PARAM *p;
+ THREAD *t;
+ bool ret = false;
+ UINT64 start_tick = 0;
+ UINT64 end_tick = 0;
+ bool use_dns_proxy = false;
+ char hostname[260];
+ UINT i;
+ // Validate arguments
+ if (ip == NULL || hostname_arg == NULL)
+ {
+ return false;
+ }
+ if (timeout == 0)
+ {
+ timeout = TIMEOUT_GETIP;
+ }
+
+ Zero(hostname, sizeof(hostname));
+ StrCpy(hostname, sizeof(hostname), hostname_arg);
+
+ i = SearchStrEx(hostname, "/", 0, true);
+ if (i != INFINITE)
+ {
+ hostname[i] = 0;
+ }
+
+ if (ipv6 == false)
+ {
+ IP ip2;
+
+ if (StrToIP(&ip2, hostname) && IsZeroIp(&ip2) == false)
+ {
+ if (IsIP4(&ip2))
+ {
+ // IPv4 address direct specification
+ Copy(ip, &ip2, sizeof(IP));
+ return true;
+ }
+ else
+ {
+ // IPv6 address direct specification
+ return false;
+ }
+ }
+ }
+ else
+ {
+ IP ip2;
+
+ if (StrToIP(&ip2, hostname) && IsZeroIp(&ip2) == false)
+ {
+ if (IsIP6(&ip2))
+ {
+ // IPv6 address direct specification
+ Copy(ip, &ip2, sizeof(IP));
+ return true;
+ }
+ else
+ {
+ // IPv4 address direct specification
+ return false;
+ }
+ }
+ }
+
+ if (only_direct_dns == false)
+ {
+ if (ipv6 == false)
+ {
+ if (IsUseDnsProxy())
+ {
+ use_dns_proxy = true;
+ }
+ }
+ }
+
+
+ p = ZeroMalloc(sizeof(GETIP_THREAD_PARAM));
+ p->Ref = NewRef();
+ StrCpy(p->HostName, sizeof(p->HostName), hostname);
+ p->IPv6 = ipv6;
+ p->Timeout = timeout;
+ p->Ok = false;
+
+ t = NewThread(GetIP4Ex6ExThread, p);
+ WaitThreadInit(t);
+
+ if (cancel == NULL)
+ {
+ WaitThread(t, timeout);
+ }
+ else
+ {
+ start_tick = Tick64();
+ end_tick = start_tick + (UINT64)timeout;
+
+ while (true)
+ {
+ UINT64 now = Tick64();
+ UINT64 remain;
+ UINT remain32;
+
+ if (*cancel)
+ {
+ break;
+ }
+
+ if (now >= end_tick)
+ {
+ break;
+ }
+
+ remain = end_tick - now;
+ remain32 = MIN((UINT)remain, 100);
+
+ if (WaitThread(t, remain32))
+ {
+ break;
+ }
+ }
+ }
+
+ ReleaseThread(t);
+
+ if (p->Ok)
+ {
+ ret = true;
+ Copy(ip, &p->Ip, sizeof(IP));
+ }
+ else
+ {
+ IP ip2;
+
+ if (only_direct_dns == false)
+ {
+ if (ipv6)
+ {
+ UINT flets_type = DetectFletsType();
+
+ // 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))
+ {
+ // 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))
+ {
+ // 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))
+ {
+ // FLET'S Hikar-Next (NTT West)
+ ret = true;
+ }
+ }
+ }
+
+ if (QueryDnsCache(&ip2, hostname))
+ {
+ ret = true;
+
+ Copy(ip, &ip2, sizeof(IP));
+ }
+ }
+
+
+ ReleaseGetIPThreadParam(p);
+
+ return ret;
+}
+bool GetIP4Ex(IP *ip, char *hostname, UINT timeout, bool *cancel)
+{
+ return GetIP4Ex6Ex(ip, hostname, timeout, false, cancel);
+}
+bool GetIP6Ex(IP *ip, char *hostname, UINT timeout, bool *cancel)
+{
+ return GetIP4Ex6Ex(ip, hostname, timeout, true, cancel);
+}
+bool GetIP4(IP *ip, char *hostname)
+{
+ return GetIP4Ex(ip, hostname, 0, NULL);
+}
+bool GetIP6(IP *ip, char *hostname)
+{
+ return GetIP6Ex(ip, hostname, 0, NULL);
+}
+
+// Perform a DNS forward lookup query
+bool GetIP(IP *ip, char *hostname)
+{
+ return GetIPEx(ip, hostname, false);
+}
+bool GetIPEx(IP *ip, char *hostname, bool ipv6)
+{
+ if (ipv6 == false)
+ {
+ return GetIP4(ip, hostname);
+ }
+ else
+ {
+ return GetIP6(ip, hostname);
+ }
+}
+bool GetIP6Inner(IP *ip, char *hostname)
+{
+ struct sockaddr_in6 in;
+ struct in6_addr addr;
+ struct addrinfo hint;
+ struct addrinfo *info;
+ // Validate arguments
+ if (ip == NULL || hostname == NULL)
+ {
+ return false;
+ }
+
+ if (IsEmptyStr(hostname))
+ {
+ return false;
+ }
+
+ if (StrCmpi(hostname, "localhost") == 0)
+ {
+ GetLocalHostIP6(ip);
+ return true;
+ }
+
+ if (StrToIP6(ip, hostname) == false && StrToIP(ip, hostname) == false)
+ {
+ // Forward resolution
+ Zero(&hint, sizeof(hint));
+ hint.ai_family = AF_INET6;
+ hint.ai_socktype = SOCK_STREAM;
+ hint.ai_protocol = IPPROTO_TCP;
+ info = NULL;
+
+ if (getaddrinfo(hostname, NULL, &hint, &info) != 0 ||
+ info->ai_family != AF_INET6)
+ {
+ if (info)
+ {
+ freeaddrinfo(info);
+ }
+ return QueryDnsCacheEx(ip, hostname, true);
+ }
+ // Forward resolution success
+ Copy(&in, info->ai_addr, sizeof(struct sockaddr_in6));
+ freeaddrinfo(info);
+
+ Copy(&addr, &in.sin6_addr, sizeof(addr));
+ InAddrToIP6(ip, &addr);
+ }
+
+ // Save Cache
+ NewDnsCache(hostname, ip);
+
+ return true;
+}
+bool GetIP4Inner(IP *ip, char *hostname)
+{
+ struct sockaddr_in in;
+ struct in_addr addr;
+ struct addrinfo hint;
+ struct addrinfo *info;
+ // Validate arguments
+ if (ip == NULL || hostname == NULL)
+ {
+ return false;
+ }
+
+ if (IsEmptyStr(hostname))
+ {
+ return false;
+ }
+
+ if (StrCmpi(hostname, "localhost") == 0)
+ {
+ SetIP(ip, 127, 0, 0, 1);
+ return true;
+ }
+
+ if (StrToIP6(ip, hostname) == false && StrToIP(ip, hostname) == false)
+ {
+ // Forward resolution
+ Zero(&hint, sizeof(hint));
+ hint.ai_family = AF_INET;
+ hint.ai_socktype = SOCK_STREAM;
+ hint.ai_protocol = IPPROTO_TCP;
+ info = NULL;
+
+ if (getaddrinfo(hostname, NULL, &hint, &info) != 0 ||
+ info->ai_family != AF_INET)
+ {
+ if (info)
+ {
+ freeaddrinfo(info);
+ }
+ return QueryDnsCache(ip, hostname);
+ }
+ // Forward resolution success
+ Copy(&in, info->ai_addr, sizeof(struct sockaddr_in));
+ freeaddrinfo(info);
+ Copy(&addr, &in.sin_addr, sizeof(addr));
+ InAddrToIP(ip, &addr);
+ }
+
+ // Save Cache
+ NewDnsCache(hostname, ip);
+
+ return true;
+}
+
+// Search in the DNS cache
+bool QueryDnsCache(IP *ip, char *hostname)
+{
+ return QueryDnsCacheEx(ip, hostname, false);
+}
+bool QueryDnsCacheEx(IP *ip, char *hostname, bool ipv6)
+{
+ DNSCACHE *c;
+ char tmp[MAX_SIZE];
+ // Validate arguments
+ if (ip == NULL || hostname == NULL)
+ {
+ return false;
+ }
+
+ GenDnsCacheKeyName(tmp, sizeof(tmp), hostname, ipv6);
+
+ c = FindDnsCache(tmp);
+ if (c == NULL)
+ {
+ return false;
+ }
+
+ Copy(ip, &c->IpAddress, sizeof(IP));
+
+ return true;
+}
+
+// Convert the IP to a string
+void IPToUniStr(wchar_t *str, UINT size, IP *ip)
+{
+ char tmp[128];
+
+ IPToStr(tmp, sizeof(tmp), ip);
+ StrToUni(str, size, tmp);
+}
+
+// Convert the IP to a string (32bit UINT)
+void IPToUniStr32(wchar_t *str, UINT size, UINT ip)
+{
+ char tmp[128];
+
+ IPToStr32(tmp, sizeof(tmp), ip);
+ StrToUni(str, size, tmp);
+}
+
+// Convert the IP to a string (128bit byte array)
+void IPToStr128(char *str, UINT size, UCHAR *ip_bytes)
+{
+ IP ip_st;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return;
+ }
+
+ SetIP6(&ip_st, ip_bytes);
+ IPToStr(str, size, &ip_st);
+}
+
+// Convert the IP to a string (32bit UINT)
+void IPToStr32(char *str, UINT size, UINT ip)
+{
+ IP ip_st;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return;
+ }
+
+ UINTToIP(&ip_st, ip);
+ IPToStr(str, size, &ip_st);
+}
+
+// Convert IPv4 or IPv6 to a string
+void IPToStr4or6(char *str, UINT size, UINT ip_4_uint, UCHAR *ip_6_bytes)
+{
+ IP ip4;
+ IP ip6;
+ IP ip;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return;
+ }
+
+ Zero(&ip, sizeof(ip));
+
+ UINTToIP(&ip4, ip_4_uint);
+ SetIP6(&ip6, ip_6_bytes);
+
+ if (IsIP6(&ip4) || (IsZeroIp(&ip4) && (IsZeroIp(&ip6) == false)))
+ {
+ Copy(&ip, &ip6, sizeof(IP));
+ }
+ else
+ {
+ Copy(&ip, &ip4, sizeof(IP));
+ }
+
+ IPToStr(str, size, &ip);
+}
+
+// Convert the IP to a string
+void IPToStr(char *str, UINT size, IP *ip)
+{
+ // Validate arguments
+ if (str == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ if (IsIP6(ip))
+ {
+ IPToStr6(str, size, ip);
+ }
+ else
+ {
+ IPToStr4(str, size, ip);
+ }
+}
+
+// Convert the IPv4 to a string
+void IPToStr4(char *str, UINT size, IP *ip)
+{
+ // Validate arguments
+ if (str == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ // Conversion
+ snprintf(str, size != 0 ? size : 64, "%u.%u.%u.%u", ip->addr[0], ip->addr[1], ip->addr[2], ip->addr[3]);
+}
+
+// Convert the string to an IP
+bool StrToIP(IP *ip, char *str)
+{
+ TOKEN_LIST *token;
+ char *tmp;
+ UINT i;
+ // Validate arguments
+ if (ip == NULL || str == NULL)
+ {
+ return false;
+ }
+
+ if (StrToIP6(ip, str))
+ {
+ return true;
+ }
+
+ Zero(ip, sizeof(IP));
+
+ tmp = CopyStr(str);
+ Trim(tmp);
+ token = ParseToken(tmp, ".");
+ Free(tmp);
+
+ if (token->NumTokens != 4)
+ {
+ FreeToken(token);
+ return false;
+ }
+ for (i = 0;i < 4;i++)
+ {
+ char *s = token->Token[i];
+ if (s[0] < '0' || s[0] > '9' ||
+ (ToInt(s) >= 256))
+ {
+ FreeToken(token);
+ return false;
+ }
+ }
+ Zero(ip, sizeof(IP));
+ for (i = 0;i < 4;i++)
+ {
+ ip->addr[i] = (UCHAR)ToInt(token->Token[i]);
+ }
+
+ FreeToken(token);
+
+ return true;
+}
+UINT StrToIP32(char *str)
+{
+ IP ip;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return 0;
+ }
+
+ if (StrToIP(&ip, str) == false)
+ {
+ return 0;
+ }
+
+ return IPToUINT(&ip);
+}
+bool UniStrToIP(IP *ip, wchar_t *str)
+{
+ char *tmp;
+ bool ret;
+
+ tmp = CopyUniToStr(str);
+ ret = StrToIP(ip, tmp);
+ Free(tmp);
+
+ return ret;
+}
+UINT UniStrToIP32(wchar_t *str)
+{
+ UINT ret;
+ char *tmp;
+
+ tmp = CopyUniToStr(str);
+ ret = StrToIP32(tmp);
+ Free(tmp);
+
+ return ret;
+}
+
+// Convert the IP to the in_addr
+void IPToInAddr(struct in_addr *addr, IP *ip)
+{
+ UINT i;
+ // Validate arguments
+ if (addr == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ Zero(addr, sizeof(struct in_addr));
+
+ if (IsIP6(ip) == false)
+ {
+ for (i = 0;i < 4;i++)
+ {
+ ((UCHAR *)addr)[i] = ip->addr[i];
+ }
+ }
+}
+
+// Convert the IP to the in6_addr
+void IPToInAddr6(struct in6_addr *addr, IP *ip)
+{
+ UINT i;
+ // Validate arguments
+ if (addr == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ Zero(addr, sizeof(struct in_addr));
+
+ if (IsIP6(ip))
+ {
+ for (i = 0;i < 16;i++)
+ {
+ ((UCHAR *)addr)[i] = ip->ipv6_addr[i];
+ }
+ }
+}
+
+// Convert the in_addr to the IP
+void InAddrToIP(IP *ip, struct in_addr *addr)
+{
+ UINT i;
+ // Validate arguments
+ if (ip == NULL || addr == NULL)
+ {
+ return;
+ }
+
+ Zero(ip, sizeof(IP));
+
+ for (i = 0;i < 4;i++)
+ {
+ ip->addr[i] = ((UCHAR *)addr)[i];
+ }
+}
+
+// Convert the in6_addr to the IP
+void InAddrToIP6(IP *ip, struct in6_addr *addr)
+{
+ UINT i;
+ // Validate arguments
+ if (ip == NULL || addr == NULL)
+ {
+ return;
+ }
+
+ ZeroIP6(ip);
+ for (i = 0;i < 16;i++)
+ {
+ ip->ipv6_addr[i] = ((UCHAR *)addr)[i];
+ }
+}
+
+// Search in the DNS cache
+DNSCACHE *FindDnsCache(char *hostname)
+{
+ return FindDnsCacheEx(hostname, false);
+}
+DNSCACHE *FindDnsCacheEx(char *hostname, bool ipv6)
+{
+ DNSCACHE *c;
+ char tmp[MAX_SIZE];
+ if (hostname == NULL)
+ {
+ return NULL;
+ }
+
+ GenDnsCacheKeyName(tmp, sizeof(tmp), hostname, ipv6);
+
+ LockDnsCache();
+ {
+ DNSCACHE t;
+ t.HostName = tmp;
+ c = Search(DnsCache, &t);
+ }
+ UnlockDnsCache();
+
+ return c;
+}
+
+// Generate the IPv4 / IPv6 key name for the DNS cache
+void GenDnsCacheKeyName(char *dst, UINT size, char *src, bool ipv6)
+{
+ // Validate arguments
+ if (dst == NULL || src == NULL)
+ {
+ return;
+ }
+
+ if (ipv6 == false)
+ {
+ StrCpy(dst, size, src);
+ }
+ else
+ {
+ Format(dst, size, "%s@ipv6", src);
+ }
+}
+
+// Registration of the new DNS cache
+void NewDnsCache(char *hostname, IP *ip)
+{
+ NewDnsCacheEx(hostname, ip, IsIP6(ip));
+}
+void NewDnsCacheEx(char *hostname, IP *ip, bool ipv6)
+{
+ DNSCACHE *c;
+ char tmp[MAX_PATH];
+ // Validate arguments
+ if (hostname == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ if (IsNetworkNameCacheEnabled() == false)
+ {
+ return;
+ }
+
+ GenDnsCacheKeyName(tmp, sizeof(tmp), hostname, ipv6);
+
+ LockDnsCache();
+ {
+ DNSCACHE t;
+
+ // Search for anything matches to the hostname first
+ t.HostName = tmp;
+ c = Search(DnsCache, &t);
+
+ if (c == NULL)
+ {
+ // Newly register
+ c = ZeroMalloc(sizeof(DNSCACHE));
+ c->HostName = CopyStr(tmp);
+
+ Copy(&c->IpAddress, ip, sizeof(IP));
+
+ Add(DnsCache, c);
+ }
+ else
+ {
+ // Update
+ Copy(&c->IpAddress, ip, sizeof(IP));
+ }
+ }
+ UnlockDnsCache();
+}
+
+// Name comparison of the DNS cache entries
+int CompareDnsCache(void *p1, void *p2)
+{
+ DNSCACHE *c1, *c2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ c1 = *(DNSCACHE **)p1;
+ c2 = *(DNSCACHE **)p2;
+ if (c1 == NULL || c2 == NULL)
+ {
+ return 0;
+ }
+
+ return StrCmpi(c1->HostName, c2->HostName);
+}
+
+// Initialization of the DNS cache
+void InitDnsCache()
+{
+ // Creating a List
+ DnsCache = NewList(CompareDnsCache);
+}
+
+// Release of the DNS cache
+void FreeDnsCache()
+{
+ LockDnsCache();
+ {
+ DNSCACHE *c;
+ UINT i;
+ for (i = 0;i < LIST_NUM(DnsCache);i++)
+ {
+ // Release the memory for the entry
+ c = LIST_DATA(DnsCache, i);
+ Free(c->HostName);
+ Free(c);
+ }
+ }
+ UnlockDnsCache();
+
+ // Release the list
+ ReleaseList(DnsCache);
+ DnsCache = NULL;
+}
+
+// Lock the DNS cache
+void LockDnsCache()
+{
+ LockList(DnsCache);
+}
+
+// Unlock the DNS cache
+void UnlockDnsCache()
+{
+ UnlockList(DnsCache);
+}
+
+// Create the SSL_CTX
+struct ssl_ctx_st *NewSSLCtx()
+{
+ struct ssl_ctx_st *ctx = SSL_CTX_new(SSLv23_method());
+
+#ifdef SSL_OP_NO_TICKET
+ SSL_CTX_set_options(ctx, SSL_OP_NO_TICKET);
+#endif // SSL_OP_NO_TICKET
+
+ return ctx;
+}
+
+// Release of the SSL_CTX
+void FreeSSLCtx(struct ssl_ctx_st *ctx)
+{
+ // Validate arguments
+ if (ctx == NULL)
+ {
+ return;
+ }
+
+ SSL_CTX_free(ctx);
+}
+
+// Initialize the network communication module
+void InitNetwork()
+{
+
+ InitDynList();
+
+
+ host_ip_address_list_cache_lock = NewLock();
+ host_ip_address_list_cache_last = 0;
+
+ num_tcp_connections = NewCounter();
+
+ // Initialization of client list
+ InitIpClientList();
+
+ // Thread related initialization
+ InitWaitThread();
+
+ // Initialization of the host name cache
+ InitHostCache();
+
+#ifdef OS_WIN32
+ // Initializing the socket library
+ Win32InitSocketLibrary();
+#else
+ UnixInitSocketLibrary();
+#endif // OS_WIN32
+
+ // Initialization of the DNS cache
+ InitDnsCache();
+
+ // Locking initialization
+ machine_name_lock = NewLock();
+ disconnect_function_lock = NewLock();
+ aho = NewLock();
+ machine_ip_process_hash_lock = NewLock();
+ socket_library_lock = NewLock();
+ //ssl_connect_lock = NewLock(); //2012.9.28 Not required for recent OpenSSL
+// ssl_accept_lock = NewLock();
+ dns_lock = NewLock();
+ unix_dns_server_addr_lock = NewLock();
+ Zero(&unix_dns_server, sizeof(unix_dns_server));
+ local_mac_list_lock = NewLock();
+
+ cipher_list_token = ParseToken(cipher_list, " ");
+
+ current_global_ip_lock = NewLock();
+ current_fqdn_lock = NewLock();
+ current_global_ip_set = false;
+
+ disable_cache = false;
+
+
+ Zero(rand_port_numbers, sizeof(rand_port_numbers));
+}
+
+// Enable the network name cache
+void EnableNetworkNameCache()
+{
+ disable_cache = false;
+}
+
+// Disable the network name cache
+void DisableNetworkNameCache()
+{
+ disable_cache = true;
+}
+
+// Get whether the network name cache is enabled
+bool IsNetworkNameCacheEnabled()
+{
+ return !disable_cache;
+}
+
+// Get the cipher algorithm list
+TOKEN_LIST *GetCipherList()
+{
+ return cipher_list_token;
+}
+
+// Get the TCP connections counter
+COUNTER *GetNumTcpConnectionsCounter()
+{
+ return num_tcp_connections;
+}
+
+// Get the current global IP address
+bool GetCurrentGlobalIP(IP *ip, bool ipv6)
+{
+ bool ret = false;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ Zero(ip, sizeof(IP));
+
+ Lock(current_global_ip_lock);
+ {
+ if (ipv6 == false)
+ {
+ Copy(ip, ¤t_glocal_ipv4, sizeof(IP));
+ }
+ else
+ {
+ Copy(ip, ¤t_glocal_ipv6, sizeof(IP));
+ }
+
+ ret = current_global_ip_set;
+ }
+ Unlock(current_global_ip_lock);
+
+ return ret;
+}
+
+// Check whether the specified IP address is assigned to the local host
+bool IsIPMyHost(IP *ip)
+{
+ LIST *o;
+ UINT i;
+ bool ret = false;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if (IsZeroIp(ip))
+ {
+ return false;
+ }
+
+ // 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++)
+ {
+ IP *p = LIST_DATA(o, i);
+
+ if (CmpIpAddr(p, ip) == 0)
+ {
+ // Matched
+ ret = true;
+ break;
+ }
+ }
+
+ FreeHostIPAddressList(o);
+
+ if (ret == false)
+ {
+ if (IsLocalHostIP(ip))
+ {
+ // localhost IP addresses
+ ret = true;
+ }
+ }
+
+ return ret;
+}
+
+// Check whether the specified IP address is a private IP address
+bool IsIPPrivate(IP *ip)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ if (ip->addr[0] == 10)
+ {
+ return true;
+ }
+
+ if (ip->addr[0] == 172)
+ {
+ if (ip->addr[1] >= 16 && ip->addr[1] <= 31)
+ {
+ return true;
+ }
+ }
+
+ if (ip->addr[0] == 192 && ip->addr[1] == 168)
+ {
+ return true;
+ }
+
+ if (ip->addr[0] == 169 && ip->addr[1] == 254)
+ {
+ return true;
+ }
+
+ if (ip->addr[0] == 100)
+ {
+ if (ip->addr[1] >= 64 && ip->addr[1] <= 127)
+ {
+ return true;
+ }
+ }
+
+ if (g_private_ip_list != NULL)
+ {
+ if (IsIP4(ip))
+ {
+ UINT ip4 = IPToUINT(ip);
+
+ return IsOnPrivateIPFile(ip4);
+ }
+ }
+
+ return false;
+}
+
+// Read a private IP list file
+void LoadPrivateIPFile()
+{
+ BUF *b = ReadDump(PRIVATE_IP_TXT_FILENAME);
+ LIST *o;
+ if (b == NULL)
+ {
+ return;
+ }
+
+ o = NewList(NULL);
+
+ while (true)
+ {
+ char *line = CfgReadNextLine(b);
+ if (line == NULL)
+ {
+ break;
+ }
+
+ Trim(line);
+
+ if (IsEmptyStr(line) == false)
+ {
+ UINT ip = 0, mask = 0;
+
+ if (ParseIpAndSubnetMask4(line, &ip, &mask))
+ {
+ PRIVATE_IP_SUBNET *p = ZeroMalloc(sizeof(PRIVATE_IP_SUBNET));
+
+ p->Ip = ip;
+ p->Mask = mask;
+ p->Ip2 = ip & mask;
+
+ Add(o, p);
+ }
+ }
+
+ Free(line);
+ }
+
+ g_private_ip_list = o;
+ g_use_privateip_file = true;
+
+ FreeBuf(b);
+}
+
+// Examine whether the specified IP address is in the private IP file
+bool IsOnPrivateIPFile(UINT ip)
+{
+ bool ret = false;
+
+ if (g_private_ip_list != NULL)
+ {
+ LIST *o = g_private_ip_list;
+ UINT i;
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ PRIVATE_IP_SUBNET *p = LIST_DATA(o, i);
+
+ if ((ip & p->Mask) == p->Ip2)
+ {
+ ret = true;
+ }
+ }
+ }
+
+ return ret;
+}
+
+// Free the private IP file
+void FreePrivateIPFile()
+{
+ if (g_private_ip_list != NULL)
+ {
+ LIST *o = g_private_ip_list;
+ UINT i;
+
+ g_private_ip_list = NULL;
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ PRIVATE_IP_SUBNET *p = LIST_DATA(o, i);
+
+ Free(p);
+ }
+
+ ReleaseList(o);
+ }
+
+ g_use_privateip_file = false;
+}
+
+// Guess the IPv4, IPv6 global address from the IP address list of the current interface
+void GetCurrentGlobalIPGuess(IP *ip, bool ipv6)
+{
+ LIST *o;
+ UINT i;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ Zero(ip, sizeof(IP));
+
+ o = GetHostIPAddressList();
+
+ if (ipv6 == false)
+ {
+ // IPv4
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *p = LIST_DATA(o, i);
+
+ if (IsIP4(p))
+ {
+ if (IsZeroIp(p) == false && IsIPPrivate(p) == false && p->addr[0] != 127)
+ {
+ Copy(ip, p, sizeof(IP));
+ }
+ }
+ }
+
+ if (IsZeroIp(ip))
+ {
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *p = LIST_DATA(o, i);
+
+ if (IsIP4(p))
+ {
+ if (IsZeroIp(p) == false && IsIPPrivate(p) && p->addr[0] != 127)
+ {
+ Copy(ip, p, sizeof(IP));
+ }
+ }
+ }
+ }
+
+ if (IsZeroIp(ip))
+ {
+ SetIP(ip, 127, 0, 0, 1);
+ }
+ }
+ else
+ {
+ // IPv6
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *p = LIST_DATA(o, i);
+
+ if (IsIP6(p))
+ {
+ UINT type = GetIPAddrType6(p);
+
+ if ((type & IPV6_ADDR_GLOBAL_UNICAST) && ((type & IPV6_ADDR_ZERO) == 0) && ((type & IPV6_ADDR_LOOPBACK) == 0))
+ {
+ Copy(ip, p, sizeof(IP));
+ }
+ }
+ }
+ }
+
+ FreeHostIPAddressList(o);
+}
+
+// Record the current global IP address
+void SetCurrentGlobalIP(IP *ip, bool ipv6)
+{
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return;
+ }
+
+ if (IsZeroIp(ip));
+ {
+ return;
+ }
+
+ Lock(current_global_ip_lock);
+ {
+ if (ipv6 == false)
+ {
+ Copy(¤t_glocal_ipv4, ip, sizeof(IP));
+ }
+ else
+ {
+ Copy(¤t_glocal_ipv6, ip, sizeof(IP));
+ }
+
+ current_global_ip_set = true;
+ }
+ Unlock(current_global_ip_lock);
+}
+
+// Release of the network communication module
+void FreeNetwork()
+{
+
+ // Release of thread-related
+ FreeWaitThread();
+
+ FreeToken(cipher_list_token);
+ cipher_list_token = NULL;
+
+ Zero(&unix_dns_server, sizeof(unix_dns_server));
+
+ // Release the locks
+ DeleteLock(unix_dns_server_addr_lock);
+ DeleteLock(dns_lock);
+ DeleteLock(ssl_accept_lock);
+ DeleteLock(machine_name_lock);
+ DeleteLock(disconnect_function_lock);
+ DeleteLock(aho);
+ DeleteLock(socket_library_lock);
+ DeleteLock(ssl_connect_lock);
+ 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;
+
+ // Release of the DNS cache
+ FreeDnsCache();
+
+ // Release of the host name cache
+ FreeHostCache();
+
+#ifdef OS_WIN32
+ // Release of the socket library
+ Win32FreeSocketLibrary();
+#else
+ UnixFreeSocketLibrary();
+#endif // OS_WIN32
+
+ DeleteCounter(num_tcp_connections);
+ num_tcp_connections = NULL;
+
+ // Release of client list
+ FreeIpClientList();
+
+ DeleteLock(current_global_ip_lock);
+ current_global_ip_lock = NULL;
+
+ DeleteLock(current_fqdn_lock);
+ current_fqdn_lock = NULL;
+
+ // Release of the local MAC list
+ if (local_mac_list != NULL)
+ {
+ FreeNicList(local_mac_list);
+ local_mac_list = NULL;
+ }
+
+ DeleteLock(local_mac_list_lock);
+ local_mac_list_lock = NULL;
+
+ DeleteLock(host_ip_address_list_cache_lock);
+ host_ip_address_list_cache_lock = NULL;
+
+ FreeHostIPAddressList(host_ip_address_cache);
+ host_ip_address_cache = NULL;
+
+
+ FreeDynList();
+
+}
+
+// Add a socket to socket list
+void AddSockList(SOCKLIST *sl, SOCK *s)
+{
+ // Validate arguments
+ if (sl == NULL || s == NULL)
+ {
+ return;
+ }
+
+ LockList(sl->SockList);
+ {
+ if (IsInList(sl->SockList, s) == false)
+ {
+ AddRef(s->ref);
+
+ Insert(sl->SockList, s);
+ }
+ }
+ UnlockList(sl->SockList);
+}
+
+// Remove the socket from socket list
+void DelSockList(SOCKLIST *sl, SOCK *s)
+{
+ // Validate arguments
+ if (sl == NULL || s == NULL)
+ {
+ return;
+ }
+
+ LockList(sl->SockList);
+ {
+ if (Delete(sl->SockList, s))
+ {
+ ReleaseSock(s);
+ }
+ }
+ UnlockList(sl->SockList);
+}
+
+// Stop all the sockets in the list and delete it
+void StopSockList(SOCKLIST *sl)
+{
+ SOCK **ss;
+ UINT num, i;
+ // Validate arguments
+ if (sl == NULL)
+ {
+ return;
+ }
+
+ LockList(sl->SockList);
+ {
+ num = LIST_NUM(sl->SockList);
+ ss = ToArray(sl->SockList);
+
+ DeleteAll(sl->SockList);
+ }
+ UnlockList(sl->SockList);
+
+ for (i = 0;i < num;i++)
+ {
+ SOCK *s = ss[i];
+
+ Disconnect(s);
+ ReleaseSock(s);
+ }
+
+ Free(ss);
+}
+
+// Delete the socket list
+void FreeSockList(SOCKLIST *sl)
+{
+ // Validate arguments
+ if (sl == NULL)
+ {
+ return;
+ }
+
+ StopSockList(sl);
+
+ ReleaseList(sl->SockList);
+
+ Free(sl);
+}
+
+// Creating a socket list
+SOCKLIST *NewSockList()
+{
+ SOCKLIST *sl = ZeroMallocFast(sizeof(SOCKLIST));
+
+ sl->SockList = NewList(NULL);
+
+ return sl;
+}
+
+// Time-out thread of the socket on Solaris
+void SocketTimeoutThread(THREAD *t, void *param)
+{
+ SOCKET_TIMEOUT_PARAM *ttparam;
+ ttparam = (SOCKET_TIMEOUT_PARAM *)param;
+
+ // Wait for time-out period
+ Select(NULL, ttparam->sock->TimeOut, ttparam->cancel, NULL);
+
+ // Disconnect if it is blocked
+ if(! ttparam->unblocked)
+ {
+// Debug("Socket timeouted\n");
+ closesocket(ttparam->sock->socket);
+ }
+ else
+ {
+// Debug("Socket timeout cancelled\n");
+ }
+}
+
+// Initialize and start the thread for time-out
+SOCKET_TIMEOUT_PARAM *NewSocketTimeout(SOCK *sock)
+{
+ SOCKET_TIMEOUT_PARAM *ttp;
+ if(! sock->AsyncMode && sock->TimeOut != TIMEOUT_INFINITE)
+ {
+// Debug("NewSockTimeout(%u)\n",sock->TimeOut);
+
+ ttp = (SOCKET_TIMEOUT_PARAM*)Malloc(sizeof(SOCKET_TIMEOUT_PARAM));
+
+ // Set the parameters of the time-out thread
+ ttp->cancel = NewCancel();
+ ttp->sock = sock;
+ ttp->unblocked = false;
+ ttp->thread = NewThread(SocketTimeoutThread, ttp);
+ return ttp;
+ }
+ return NULL;
+}
+
+// Stop and free the thread for timeout
+void FreeSocketTimeout(SOCKET_TIMEOUT_PARAM *ttp)
+{
+ if(ttp == NULL)
+ {
+ return;
+ }
+
+ ttp->unblocked = true;
+ Cancel(ttp->cancel);
+ WaitThread(ttp->thread, INFINITE);
+ ReleaseCancel(ttp->cancel);
+ ReleaseThread(ttp->thread);
+ Free(ttp);
+// Debug("FreeSocketTimeout succeed\n");
+ return;
+}
+
+// Parse the IP address and subnet mask
+bool ParseIpAndSubnetMask46(char *src, IP *ip, IP *mask)
+{
+ // Validate arguments
+ if (src == NULL || ip == NULL || mask == NULL)
+ {
+ return false;
+ }
+
+ if (ParseIpAndMask46(src, ip, mask) == false)
+ {
+ return false;
+ }
+
+ if (IsIP4(ip))
+ {
+ return IsSubnetMask4(mask);
+ }
+ else
+ {
+ return IsSubnetMask6(mask);
+ }
+}
+bool ParseIpAndSubnetMask6(char *src, IP *ip, IP *mask)
+{
+ if (ParseIpAndSubnetMask46(src, ip, mask) == false)
+ {
+ return false;
+ }
+
+ if (IsIP6(ip) == false)
+ {
+ return false;
+ }
+
+ return true;
+}
+bool ParseIpAndSubnetMask4(char *src, UINT *ip, UINT *mask)
+{
+ IP ip2, mask2;
+ // Validate arguments
+ if (src == NULL)
+ {
+ return false;
+ }
+
+ if (ParseIpAndSubnetMask46(src, &ip2, &mask2) == false)
+ {
+ return false;
+ }
+
+ if (IsIP4(&ip2) == false)
+ {
+ return false;
+ }
+
+ if (ip != NULL)
+ {
+ *ip = IPToUINT(&ip2);
+ }
+
+ if (mask != NULL)
+ {
+ *mask = IPToUINT(&mask2);
+ }
+
+ return true;
+}
+
+
+// Parse the IP address and the mask
+bool ParseIpAndMask46(char *src, IP *ip, IP *mask)
+{
+ TOKEN_LIST *t;
+ char *ipstr;
+ char *subnetstr;
+ bool ret = false;
+ IP ip2;
+ IP mask2;
+ // Validate arguments
+ if (src == NULL || ip == NULL || mask == NULL)
+ {
+ return false;
+ }
+
+ Zero(&ip2, sizeof(IP));
+ Zero(&mask2, sizeof(IP));
+
+ t = ParseToken(src, "/");
+ if (t->NumTokens != 2)
+ {
+ FreeToken(t);
+ return false;
+ }
+
+ ipstr = t->Token[0];
+ subnetstr = t->Token[1];
+ Trim(ipstr);
+ Trim(subnetstr);
+
+ if (StrToIP(&ip2, ipstr))
+ {
+ if (StrToIP(&mask2, subnetstr))
+ {
+ // Compare the kind of the mask part and the IP address part to confirm same
+ if (IsIP6(&ip2) && IsIP6(&mask2))
+ {
+ // Both are IPv6
+ ret = true;
+ Copy(ip, &ip2, sizeof(IP));
+ Copy(mask, &mask2, sizeof(IP));
+ }
+ else if (IsIP4(&ip2) && IsIP4(&mask2))
+ {
+ // Both are IPv4
+ ret = true;
+ Copy(ip, &ip2, sizeof(IP));
+ Copy(mask, &mask2, sizeof(IP));
+ }
+ }
+ else
+ {
+ if (IsNum(subnetstr))
+ {
+ UINT i = ToInt(subnetstr);
+ // Mask part is a number
+ if (IsIP6(&ip2) && i <= 128)
+ {
+ ret = true;
+ Copy(ip, &ip2, sizeof(IP));
+ IntToSubnetMask6(mask, i);
+ }
+ else if (i <= 32)
+ {
+ ret = true;
+ Copy(ip, &ip2, sizeof(IP));
+ IntToSubnetMask4(mask, i);
+ }
+ }
+ }
+ }
+
+ FreeToken(t);
+
+ return ret;
+}
+bool ParseIpAndMask4(char *src, UINT *ip, UINT *mask)
+{
+ IP ip_ip, ip_mask;
+ if (ParseIpAndMask46(src, &ip_ip, &ip_mask) == false)
+ {
+ return false;
+ }
+
+ if (IsIP4(&ip_ip) == false)
+ {
+ return false;
+ }
+
+ if (ip != NULL)
+ {
+ *ip = IPToUINT(&ip_ip);
+ }
+
+ if (mask != NULL)
+ {
+ *mask = IPToUINT(&ip_mask);
+ }
+
+ return true;
+}
+bool ParseIpAndMask6(char *src, IP *ip, IP *mask)
+{
+ if (ParseIpAndMask46(src, ip, mask) == false)
+ {
+ return false;
+ }
+
+ if (IsIP6(ip) == false)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+
+// Check whether the specification of the IPv4 address is correct
+bool IsIpStr4(char *str)
+{
+ // Validate arguments
+ if (str == NULL)
+ {
+ return false;
+ }
+
+ if (StrToIP32(str) == 0 && StrCmpi(str, "0.0.0.0") != 0)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Check whether the specification of the IPv6 address is correct
+bool IsIpStr6(char *str)
+{
+ IP ip;
+ // Validate arguments
+ if (str == NULL)
+ {
+ return false;
+ }
+
+ if (StrToIP6(&ip, str) == false)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Check whether the IP address specification is correct
+bool IsIpStr46(char *str)
+{
+ if (IsIpStr4(str) || IsIpStr6(str))
+ {
+ return true;
+ }
+
+ return false;
+}
+
+
+// Convert the string to an IPv4 mask
+bool StrToMask4(IP *mask, char *str)
+{
+ // Validate arguments
+ if (mask == NULL || str == NULL)
+ {
+ return false;
+ }
+
+ if (str[0] == '/')
+ {
+ str++;
+ }
+
+ if (IsNum(str))
+ {
+ UINT n = ToInt(str);
+
+ if (n <= 32)
+ {
+ IntToSubnetMask4(mask, n);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ else
+ {
+ if (StrToIP(mask, str) == false)
+ {
+ return false;
+ }
+ else
+ {
+ return IsIP4(mask);
+ }
+ }
+}
+
+// Convert the string to an IPv6 mask
+bool StrToMask6(IP *mask, char *str)
+{
+ // Validate arguments
+ if (mask == NULL || str == NULL)
+ {
+ return false;
+ }
+
+ if (str[0] == '/')
+ {
+ str++;
+ }
+
+ if (IsNum(str))
+ {
+ UINT n = ToInt(str);
+
+ if (n <= 128)
+ {
+ IntToSubnetMask6(mask, n);
+ return true;
+ }
+ else
+ {
+ return false;
+ }
+ }
+ else
+ {
+ if (StrToIP(mask, str) == false)
+ {
+ return false;
+ }
+ else
+ {
+ return IsIP6(mask);
+ }
+ }
+}
+bool StrToMask6Addr(IPV6_ADDR *mask, char *str)
+{
+ IP ip;
+
+ if (StrToMask6(&ip, str) == false)
+ {
+ return false;
+ }
+
+ if (IPToIPv6Addr(mask, &ip) == false)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Convert the string to an IPv4 / IPv6 mask
+bool StrToMask46(IP *mask, char *str, bool ipv6)
+{
+ if (ipv6)
+ {
+ return StrToMask6(mask, str);
+ }
+ else
+ {
+ return StrToMask4(mask, str);
+ }
+}
+
+
+// Convert the IPv4 / IPv6 mask to a string
+void MaskToStr(char *str, UINT size, IP *mask)
+{
+ MaskToStrEx(str, size, mask, false);
+}
+void MaskToStrEx(char *str, UINT size, IP *mask, bool always_full_address)
+{
+ // Validate arguments
+ if (str == NULL || mask == NULL)
+ {
+ return;
+ }
+
+ if (always_full_address == false && IsSubnetMask(mask))
+ {
+ ToStr(str, SubnetMaskToInt(mask));
+ }
+ else
+ {
+ IPToStr(str, size, mask);
+ }
+}
+void MaskToStr32(char *str, UINT size, UINT mask)
+{
+ MaskToStr32Ex(str, size, mask, false);
+}
+void MaskToStr32Ex(char *str, UINT size, UINT mask, bool always_full_address)
+{
+ IP ip;
+
+ UINTToIP(&ip, mask);
+
+ MaskToStrEx(str, size, &ip, always_full_address);
+}
+void Mask6AddrToStrEx(char *str, UINT size, IPV6_ADDR *mask, bool always_full_address)
+{
+ IP ip;
+
+ // Validate arguments
+ if (str == NULL || mask == NULL)
+ {
+ StrCpy(str, size, "");
+ return;
+ }
+
+ IPv6AddrToIP(&ip, mask);
+
+ MaskToStrEx(str, size, &ip, always_full_address);
+}
+void Mask6AddrToStr(char *str, UINT size, IPV6_ADDR *mask)
+{
+ Mask6AddrToStrEx(str, size, mask, false);
+}
+
+// Disconnecting of the tube
+void TubeDisconnect(TUBE *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ if (t->TubePairData == NULL)
+ {
+ return;
+ }
+
+ Lock(t->TubePairData->Lock);
+ {
+ t->TubePairData->IsDisconnected = true;
+
+ Set(t->TubePairData->Event1);
+ Set(t->TubePairData->Event2);
+ SetSockEvent(t->TubePairData->SockEvent1);
+ SetSockEvent(t->TubePairData->SockEvent2);
+ }
+ Unlock(t->TubePairData->Lock);
+}
+
+// Creating a tube pair
+void NewTubePair(TUBE **t1, TUBE **t2, UINT size_of_header)
+{
+ TUBEPAIR_DATA *d;
+ // Validate arguments
+ if (t1 == NULL || t2 == NULL)
+ {
+ return;
+ }
+
+ *t1 = NewTube(size_of_header);
+ *t2 = NewTube(size_of_header);
+
+ (*t1)->IndexInTubePair = 0;
+ (*t2)->IndexInTubePair = 1;
+
+ d = NewTubePairData();
+ AddRef(d->Ref);
+
+ (*t1)->TubePairData = d;
+ (*t2)->TubePairData = d;
+
+ d->Event1 = (*t1)->Event;
+ d->Event2 = (*t2)->Event;
+
+ AddRef(d->Event1->ref);
+ AddRef(d->Event2->ref);
+}
+
+// Creating a tube pair data
+TUBEPAIR_DATA *NewTubePairData()
+{
+ TUBEPAIR_DATA *d = ZeroMalloc(sizeof(TUBEPAIR_DATA));
+
+ d->Ref = NewRef();
+
+ d->Lock = NewLock();
+
+ return d;
+}
+
+// Set the SockEvent to the tube
+void SetTubeSockEvent(TUBE *t, SOCK_EVENT *e)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ Lock(t->Lock);
+ {
+ TUBEPAIR_DATA *d;
+
+ if (t->SockEvent != e)
+ {
+ if (t->SockEvent != NULL)
+ {
+ ReleaseSockEvent(t->SockEvent);
+ }
+
+ if (e != NULL)
+ {
+ AddRef(e->ref);
+ }
+
+ t->SockEvent = e;
+ }
+
+ d = t->TubePairData;
+
+ if (d != NULL)
+ {
+ Lock(d->Lock);
+ {
+ SOCK_EVENT **sep = (t->IndexInTubePair == 0 ? &d->SockEvent1 : &d->SockEvent2);
+
+ if (*sep != e)
+ {
+ if (*sep != NULL)
+ {
+ ReleaseSockEvent(*sep);
+ }
+
+ if (e != NULL)
+ {
+ AddRef(e->ref);
+ }
+
+ *sep = e;
+ }
+ }
+ Unlock(d->Lock);
+ }
+ }
+ Unlock(t->Lock);
+}
+
+// Release of the tube pair data
+void ReleaseTubePairData(TUBEPAIR_DATA *d)
+{
+ // Validate arguments
+ if (d == NULL)
+ {
+ return;
+ }
+
+ if (Release(d->Ref) == 0)
+ {
+ CleanupTubePairData(d);
+ }
+}
+void CleanupTubePairData(TUBEPAIR_DATA *d)
+{
+ // Validate arguments
+ if (d == NULL)
+ {
+ return;
+ }
+
+ ReleaseEvent(d->Event1);
+ ReleaseEvent(d->Event2);
+
+ ReleaseSockEvent(d->SockEvent1);
+ ReleaseSockEvent(d->SockEvent2);
+
+ DeleteLock(d->Lock);
+
+ Free(d);
+}
+
+// Check whether the tube is connected to the opponent still
+bool IsTubeConnected(TUBE *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return false;
+ }
+
+ if (t->TubePairData == NULL)
+ {
+ return true;
+ }
+
+ if (t->TubePairData->IsDisconnected)
+ {
+ return false;
+ }
+
+ return true;
+}
+
+// Send the data to the tube
+bool TubeSend(TUBE *t, void *data, UINT size, void *header)
+{
+ return TubeSendEx(t, data, size, header, false);
+}
+bool TubeSendEx(TUBE *t, void *data, UINT size, void *header, bool no_flush)
+{
+ return TubeSendEx2(t, data, size, header, no_flush, 0);
+}
+bool TubeSendEx2(TUBE *t, void *data, UINT size, void *header, bool no_flush, UINT max_num_in_queue)
+{
+ // Validate arguments
+ if (t == NULL || data == NULL || size == 0)
+ {
+ return false;
+ }
+
+ if (IsTubeConnected(t) == false)
+ {
+ return false;
+ }
+
+ LockQueue(t->Queue);
+ {
+ if (max_num_in_queue == 0 || (t->Queue->num_item <= max_num_in_queue))
+ {
+ InsertQueue(t->Queue, NewTubeData(data, size, header, t->SizeOfHeader));
+ }
+ else
+ {
+ no_flush = true;
+ }
+ }
+ UnlockQueue(t->Queue);
+
+ if (no_flush == false)
+ {
+ Set(t->Event);
+ SetSockEvent(t->SockEvent);
+ }
+
+ return true;
+}
+
+// Flush the tube
+void TubeFlush(TUBE *t)
+{
+ TubeFlushEx(t, false);
+}
+void TubeFlushEx(TUBE *t, bool force)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ if (IsTubeConnected(t) == false)
+ {
+ return;
+ }
+
+ if (force == false)
+ {
+ if (t->Queue->num_item == 0)
+ {
+ return;
+ }
+ }
+
+ Set(t->Event);
+ SetSockEvent(t->SockEvent);
+}
+
+// Receive the data from the tube (asynchronous)
+TUBEDATA *TubeRecvAsync(TUBE *t)
+{
+ TUBEDATA *d;
+ // Validate arguments
+ if (t == NULL)
+ {
+ return NULL;
+ }
+
+ if (IsTubeConnected(t) == false)
+ {
+ return NULL;
+ }
+
+ LockQueue(t->Queue);
+ {
+ d = GetNext(t->Queue);
+ }
+ UnlockQueue(t->Queue);
+
+ return d;
+}
+
+// Get the SockEvent associated with the tube
+SOCK_EVENT *GetTubeSockEvent(TUBE *t)
+{
+ SOCK_EVENT *e = NULL;
+ // Validate arguments
+ if (t == NULL)
+ {
+ return NULL;
+ }
+
+ Lock(t->Lock);
+ {
+ if (t->SockEvent != NULL)
+ {
+ AddRef(t->SockEvent->ref);
+
+ e = t->SockEvent;
+ }
+ }
+ Unlock(t->Lock);
+
+ return e;
+}
+
+// Receive the data from the tube (synchronous)
+TUBEDATA *TubeRecvSync(TUBE *t, UINT timeout)
+{
+ UINT64 start_tick, timeout_tick;
+ TUBEDATA *d = NULL;
+ // Validate arguments
+ if (t == NULL)
+ {
+ return NULL;
+ }
+
+ if (IsTubeConnected(t) == false)
+ {
+ return NULL;
+ }
+
+ start_tick = Tick64();
+ timeout_tick = start_tick + (UINT64)timeout;
+
+ while (true)
+ {
+ UINT64 now = Tick64();
+ UINT remain_time;
+ SOCK_EVENT *e;
+ UINT interval;
+
+ d = NULL;
+
+ if (IsTubeConnected(t) == false)
+ {
+ break;
+ }
+
+ LockQueue(t->Queue);
+ {
+ d = GetNext(t->Queue);
+ }
+ UnlockQueue(t->Queue);
+
+ if (d != NULL)
+ {
+ break;
+ }
+
+ if (timeout != INFINITE && now >= timeout_tick)
+ {
+ return NULL;
+ }
+
+ remain_time = (UINT)(timeout_tick - now);
+
+ e = GetTubeSockEvent(t);
+
+ interval = (timeout == INFINITE ? INFINITE : remain_time);
+
+ if (e == NULL)
+ {
+ Wait(t->Event, interval);
+ }
+ else
+ {
+ WaitSockEvent(e, interval);
+
+ ReleaseSockEvent(e);
+ }
+ }
+
+ return d;
+}
+
+// Creating a tube
+TUBE *NewTube(UINT size_of_header)
+{
+ TUBE *t = ZeroMalloc(sizeof(TUBE));
+
+ t->Event = NewEvent();
+ t->Queue = NewQueue();
+ t->Ref = NewRef();
+ t->Lock = NewLock();
+ t->SockEvent = NewSockEvent();
+
+ t->SizeOfHeader = size_of_header;
+
+ return t;
+}
+
+// Release of the tube
+void ReleaseTube(TUBE *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ if (Release(t->Ref) == 0)
+ {
+ CleanupTube(t);
+ }
+}
+void CleanupTube(TUBE *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ while (true)
+ {
+ TUBEDATA *d = GetNext(t->Queue);
+ if (d == NULL)
+ {
+ break;
+ }
+
+ FreeTubeData(d);
+ }
+
+ ReleaseQueue(t->Queue);
+ ReleaseEvent(t->Event);
+ ReleaseSockEvent(t->SockEvent);
+
+ ReleaseTubePairData(t->TubePairData);
+
+ DeleteLock(t->Lock);
+
+ Free(t);
+}
+
+// Creating a tube data
+TUBEDATA *NewTubeData(void *data, UINT size, void *header, UINT header_size)
+{
+ TUBEDATA *d;
+ // Validate arguments
+ if (size == 0 || data == NULL)
+ {
+ return NULL;
+ }
+
+ d = ZeroMalloc(sizeof(TUBEDATA));
+
+ d->Data = Clone(data, size);
+ d->DataSize = size;
+ if (header != NULL)
+ {
+ d->Header = Clone(header, header_size);
+ d->HeaderSize = header_size;
+ }
+ else
+ {
+ d->Header = ZeroMalloc(header_size);
+ }
+
+ return d;
+}
+
+// Release of the tube data
+void FreeTubeData(TUBEDATA *d)
+{
+ // Validate arguments
+ if (d == NULL)
+ {
+ return;
+ }
+
+ Free(d->Data);
+ Free(d->Header);
+
+ Free(d);
+}
+
+// Release of the IP address list of the host
+void FreeHostIPAddressList(LIST *o)
+{
+ UINT i;
+ // Validate arguments
+ if (o == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *ip = LIST_DATA(o, i);
+
+ Free(ip);
+ }
+
+ ReleaseList(o);
+}
+
+// Get whether the specified IP address is held by this host
+bool IsMyIPAddress(IP *ip)
+{
+ LIST *o;
+ UINT i;
+ bool ret = false;
+ // Validate arguments
+ if (ip == NULL)
+ {
+ return false;
+ }
+
+ o = GetHostIPAddressList();
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *a = LIST_DATA(o, i);
+
+ if (CmpIpAddr(ip, a) == 0)
+ {
+ ret = true;
+ break;
+ }
+ }
+
+ FreeHostIPAddressList(o);
+
+ return ret;
+}
+
+// Add the IP address to the list
+void AddHostIPAddressToList(LIST *o, IP *ip)
+{
+ IP *r;
+ // Validate arguments
+ if (o == NULL || ip == NULL)
+ {
+ return;
+ }
+
+ r = Search(o, ip);
+ if (r != NULL)
+ {
+ return;
+ }
+
+ Insert(o, Clone(ip, sizeof(IP)));
+}
+
+// Comparison of the IP address list items
+int CmpIpAddressList(void *p1, void *p2)
+{
+ IP *ip1, *ip2;
+ UINT r;
+ // Validate arguments
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ ip1 = *(IP **)p1;
+ ip2 = *(IP **)p2;
+ if (ip1 == NULL || ip2 == NULL)
+ {
+ return 0;
+ }
+
+ // IPv4 < IPv6
+ r = COMPARE_RET(IsIP6(ip1), IsIP6(ip2));
+ if (r != 0)
+ {
+ return r;
+ }
+
+ // any > specified IP
+ if (IsZeroIP(ip1) && IsZeroIP(ip2) == false)
+ {
+ return 1;
+ }
+ if (IsZeroIP(ip1) == false && IsZeroIP(ip2))
+ {
+ return -1;
+ }
+
+ // local > others
+ if (IsLocalHostIP(ip1) && IsLocalHostIP(ip2) == false)
+ {
+ return 1;
+ }
+ if (IsLocalHostIP(ip1) == false && IsLocalHostIP(ip2))
+ {
+ return -1;
+ }
+
+ // ip address
+ r = CmpIpAddr(ip1, ip2);
+ if (r != 0)
+ {
+ return r;
+ }
+
+ // interface index
+ if (IsIP6(ip1))
+ {
+ r = COMPARE_RET(ip1->ipv6_scope_id, ip2->ipv6_scope_id);
+ }
+ else
+ {
+ r = 0;
+ }
+
+ return r;
+}
+
+// Get the IP address list of the host (using cache)
+LIST *GetHostIPAddressList()
+{
+ LIST *o = NULL;
+ if (host_ip_address_list_cache_lock == NULL)
+ {
+ return GetHostIPAddressListInternal();
+ }
+
+ Lock(host_ip_address_list_cache_lock);
+ {
+ 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)
+ {
+ if (host_ip_address_cache != NULL)
+ {
+ FreeHostIPAddressList(host_ip_address_cache);
+ }
+
+ host_ip_address_cache = GetHostIPAddressListInternal();
+
+ host_ip_address_list_cache_last = now;
+ }
+
+ o = CloneIPAddressList(host_ip_address_cache);
+ }
+ Unlock(host_ip_address_list_cache_lock);
+
+ if (o == NULL)
+ {
+ o = GetHostIPAddressListInternal();
+ }
+
+ return o;
+}
+
+// Copy of the IP address list
+LIST *CloneIPAddressList(LIST *o)
+{
+ LIST *ret;
+ UINT i;
+ // Validate arguments
+ if (o == NULL)
+ {
+ return NULL;
+ }
+
+ ret = NewListFast(CmpIpAddressList);
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ IP *ip = LIST_DATA(o, i);
+
+ if (ip != NULL)
+ {
+ ip = Clone(ip, sizeof(IP));
+
+ Add(ret, ip);
+ }
+ }
+
+ return ret;
+}
+
+// Get an IP address list of the host
+LIST *GetHostIPAddressListInternal()
+{
+ char hostname[MAX_SIZE];
+ LIST *o;
+ IP any6, any4;
+ IP local6, local4;
+ bool is_v6_supported = IsIPv6Supported();
+
+ GetLocalHostIP4(&local4);
+ GetLocalHostIP6(&local6);
+
+ ZeroIP4(&any4);
+ ZeroIP6(&any6);
+
+ Zero(hostname, sizeof(hostname));
+
+ gethostname(hostname, sizeof(hostname));
+
+ o = NewListFast(CmpIpAddressList);
+
+ // any
+ AddHostIPAddressToList(o, &any4);
+ if (is_v6_supported)
+ {
+ AddHostIPAddressToList(o, &any6);
+ }
+
+ // localhost
+ AddHostIPAddressToList(o, &local4);
+ if (is_v6_supported)
+ {
+ AddHostIPAddressToList(o, &local6);
+ }
+
+#ifndef MAYAQUA_SUPPORTS_GETIFADDRS
+ // IPv4
+ if (true)
+ {
+ struct sockaddr_in in;
+ struct in_addr addr;
+ struct addrinfo hint;
+ struct addrinfo *info;
+
+ Zero(&hint, sizeof(hint));
+ hint.ai_family = AF_INET;
+ hint.ai_socktype = SOCK_DGRAM;
+ hint.ai_protocol = IPPROTO_UDP;
+ info = NULL;
+
+ if (getaddrinfo(hostname, NULL, &hint, &info) == 0)
+ {
+ if (info->ai_family == AF_INET)
+ {
+ struct addrinfo *current = info;
+ while (current != NULL)
+ {
+ IP ip;
+
+ Copy(&in, current->ai_addr, sizeof(in));
+ Copy(&addr, &in.sin_addr, sizeof(addr));
+
+ InAddrToIP(&ip, &addr);
+ AddHostIPAddressToList(o, &ip);
+
+ current = current->ai_next;
+ }
+ }
+
+ freeaddrinfo(info);
+ }
+ }
+
+#ifndef UNIX_LINUX
+ // IPv6
+ if (is_v6_supported)
+ {
+ struct sockaddr_in6 in;
+ struct in6_addr addr;
+ struct addrinfo hint;
+ struct addrinfo *info;
+
+ Zero(&hint, sizeof(hint));
+ hint.ai_family = AF_INET6;
+ hint.ai_socktype = SOCK_DGRAM;
+ hint.ai_protocol = IPPROTO_UDP;
+ info = NULL;
+
+ if (getaddrinfo(hostname, NULL, &hint, &info) == 0)
+ {
+ if (info->ai_family == AF_INET6)
+ {
+ struct addrinfo *current = info;
+ while (current != NULL)
+ {
+ IP ip;
+
+ Copy(&in, current->ai_addr, sizeof(in));
+ Copy(&addr, &in.sin6_addr, sizeof(addr));
+
+ InAddrToIP6(&ip, &addr);
+ ip.ipv6_scope_id = in.sin6_scope_id;
+
+ AddHostIPAddressToList(o, &ip);
+
+ current = current->ai_next;
+ }
+ }
+
+ freeaddrinfo(info);
+ }
+ }
+#endif // UNIX_LINUX
+#endif // MAYAQUA_SUPPORTS_GETIFADDRS
+
+#ifdef MAYAQUA_SUPPORTS_GETIFADDRS
+ // If the getifaddrs is available, use this
+ if (true)
+ {
+ struct ifaddrs *aa = NULL;
+
+ if (getifaddrs(&aa) == 0)
+ {
+ struct ifaddrs *a = aa;
+
+ while (a != NULL)
+ {
+ if (a->ifa_addr != NULL)
+ {
+ 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;
+
+ 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;
+
+ InAddrToIP6(&ip, addr);
+ ip.ipv6_scope_id = scope_id;
+
+ AddHostIPAddressToList(o, &ip);
+ }
+ }
+
+ a = a->ifa_next;
+ }
+
+ freeifaddrs(aa);
+ }
+ }
+#endif // MAYAQUA_SUPPORTS_GETIFADDRS
+
+ return o;
+}
+
+// Get whether the UDP listener opens the specified port
+bool IsUdpPortOpened(UDPLISTENER *u, IP *server_ip, UINT port)
+{
+ UINT i;
+ // Validate arguments
+ if (u == NULL || port == 0)
+ {
+ return false;
+ }
+
+ if (server_ip != NULL)
+ {
+ for (i = 0;i < LIST_NUM(u->SockList);i++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i);
+
+ if (us->Sock != NULL && us->HasError == false)
+ {
+ if (us->Port == port)
+ {
+ if (CmpIpAddr(server_ip, &us->IpAddress) == 0)
+ {
+ return true;
+ }
+ }
+ }
+ }
+ }
+
+ for (i = 0;i < LIST_NUM(u->SockList);i++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i);
+
+ if (us->Sock != NULL && us->HasError == false)
+ {
+ if (us->Port == port)
+ {
+ if (IsZeroIP(&us->IpAddress))
+ {
+ return true;
+ }
+ }
+ }
+ }
+
+ return false;
+}
+
+// IP address acquisition thread
+void QueryIpThreadMain(THREAD *thread, void *param)
+{
+ QUERYIPTHREAD *t = (QUERYIPTHREAD *)param;
+ // Validate arguments
+ if (thread == NULL || param == NULL)
+ {
+ return;
+ }
+
+ while (t->Halt == false)
+ {
+ UINT next_wait_time = 0;
+ IP ip;
+ bool ok = false;
+
+ if (GetIP4Ex(&ip, t->Hostname, 5000, &t->Halt))
+ {
+ if (IsZeroIP(&ip) == false)
+ {
+ Lock(t->Lock);
+ {
+ Copy(&t->Ip, &ip, sizeof(IP));
+ }
+ Unlock(t->Lock);
+
+ ok = true;
+ }
+ }
+
+ if (ok == false)
+ {
+ next_wait_time = t->IntervalLastNg;
+ }
+ else
+ {
+ next_wait_time = t->IntervalLastOk;
+ }
+
+ if (t->Halt)
+ {
+ break;
+ }
+
+ Wait(t->HaltEvent, next_wait_time);
+ }
+}
+
+// Creating an IP address acquisition thread
+QUERYIPTHREAD *NewQueryIpThread(char *hostname, UINT interval_last_ok, UINT interval_last_ng)
+{
+ QUERYIPTHREAD *t;
+
+ t = ZeroMalloc(sizeof(QUERYIPTHREAD));
+
+ t->HaltEvent = NewEvent();
+ t->Lock = NewLock();
+ StrCpy(t->Hostname, sizeof(t->Hostname), hostname);
+ t->IntervalLastOk = interval_last_ok;
+ t->IntervalLastNg = interval_last_ng;
+
+ t->Thread = NewThread(QueryIpThreadMain, t);
+
+ return t;
+}
+
+// Get the results of the IP address acquisition thread
+bool GetQueryIpThreadResult(QUERYIPTHREAD *t, IP *ip)
+{
+ bool ret = false;
+ Zero(ip, sizeof(IP));
+ // Validate arguments
+ if (t == NULL || ip == NULL)
+ {
+ return false;
+ }
+
+ Lock(t->Lock);
+
+ if (IsZero(&t->Ip, sizeof(IP)))
+ {
+ ret = false;
+ }
+ else
+ {
+ Copy(ip, &t->Ip, sizeof(IP));
+ }
+
+ Unlock(t->Lock);
+
+ return ret;
+}
+
+// Release of the IP address acquisition thread
+void FreeQueryIpThread(QUERYIPTHREAD *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ t->Halt = true;
+ Set(t->HaltEvent);
+
+ WaitThread(t->Thread, INFINITE);
+ ReleaseThread(t->Thread);
+
+ ReleaseEvent(t->HaltEvent);
+
+ DeleteLock(t->Lock);
+
+ Free(t);
+}
+
+// Get a public port list which is known by UDP listener
+void UdpListenerGetPublicPortList(UDPLISTENER *u, char *dst, UINT size)
+{
+ UINT k;
+ // Validate arguments
+ ClearStr(dst, size);
+ if (u == NULL || dst == NULL)
+ {
+ return;
+ }
+
+ LockList(u->PortList);
+ {
+ for (k = 0;k < LIST_NUM(u->SockList);k++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k);
+
+ if (us->PublicPort != 0)
+ {
+ char tmp[64];
+ ToStr(tmp, us->PublicPort);
+ StrCat(dst, size, tmp);
+ StrCat(dst, size, " ");
+ }
+ }
+ }
+ UnlockList(u->PortList);
+
+ Trim(dst);
+}
+
+// UDP listener thread
+void UdpListenerThread(THREAD *thread, void *param)
+{
+ UDPLISTENER *u = (UDPLISTENER *)param;
+ UINT i, j, k;
+ UINT buf_size = 65536;
+ void *buf;
+ bool cont_flag;
+ BUF *ip_list_buf = NewBuf();
+ // Validate arguments
+ if (thread == NULL || param == NULL)
+ {
+ return;
+ }
+
+ buf = Malloc(buf_size);
+
+ // Initializing the socket list
+ u->SockList = NewList(NULL);
+
+ u->LastCheckTick = 0;
+
+// u->PollMyIpAndPort = true;
+
+ // Main loop
+ while (u->Halt == false)
+ {
+ LIST *recv_list;
+ UINT64 now = Tick64();
+ UINT interval;
+ bool stage_changed = false;
+ IP nat_t_ip;
+ Zero(&nat_t_ip, sizeof(nat_t_ip));
+
+ if (u->LastCheckTick == 0 || (now >= (u->LastCheckTick + UDPLISTENER_CHECK_INTERVAL)))
+ {
+ LIST *iplist;
+ LIST *del_us_list = NewListFast(NULL);
+ BUF *ip_list_buf_new = NewBuf();
+
+ u->LastCheckTick = now;
+
+ // Obtain an IP address list
+ iplist = GetHostIPAddressList();
+
+ LockList(u->PortList);
+ {
+ for (k = 0;k < LIST_NUM(u->SockList);k++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k);
+
+ us->Mark = false;
+ }
+
+ // 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++)
+ {
+ IP *ip = LIST_DATA(iplist, i);
+
+ WriteBuf(ip_list_buf_new, ip, sizeof(IP));
+
+ for (j = 0;j < LIST_NUM(u->PortList);j++)
+ {
+ UINT k;
+ UINT *port = LIST_DATA(u->PortList, j);
+ bool existing = false;
+
+ if (IsZeroIP(ip) && (IS_SPECIAL_PORT(*port)))
+ {
+ continue;
+ }
+
+
+ for (k = 0;k < LIST_NUM(u->SockList);k++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k);
+
+ if (CmpIpAddr(&us->IpAddress, ip) == 0 && us->Port == *port)
+ {
+ existing = true;
+
+ us->Mark = true;
+
+ break;
+ }
+ }
+
+ if (existing == false)
+ {
+ UDPLISTENER_SOCK *us = ZeroMalloc(sizeof(UDPLISTENER_SOCK));
+
+ Copy(&us->IpAddress, ip, sizeof(IP));
+ us->Port = *port;
+
+ us->Mark = true;
+
+ Add(u->SockList, us);
+ }
+ }
+ }
+
+ // 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++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k);
+
+ if (us->Mark == false || us->HasError)
+ {
+ Debug("mark=%u error=%u\n", us->Mark, us->HasError);
+ Add(del_us_list, us);
+ }
+ }
+
+ for (i = 0;i < LIST_NUM(del_us_list);i++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(del_us_list, i);
+
+ char ipstr[MAX_SIZE];
+
+ IPToStr(ipstr, sizeof(ipstr), &us->IpAddress);
+ Debug("Closed UDP Port %u at %s.\n", us->Port, ipstr);
+
+ Delete(u->SockList, us);
+
+ if (us->Sock != NULL)
+ {
+ Disconnect(us->Sock);
+ ReleaseSock(us->Sock);
+ }
+
+ Free(us);
+ }
+ }
+ UnlockList(u->PortList);
+
+ // Open the UDP sockets which is not opend yet
+ for (k = 0;k < LIST_NUM(u->SockList);k++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k);
+
+ if (us->Sock == NULL)
+ {
+ char ipstr[MAX_SIZE];
+
+ IPToStr(ipstr, sizeof(ipstr), &us->IpAddress);
+
+ if (us->ErrorDebugDisplayed == false)
+ {
+ Debug("Opening UDP Port %u at %s ...", us->Port, ipstr);
+ }
+
+ us->Sock = NewUDPEx2(us->Port, IsIP6(&us->IpAddress), &us->IpAddress);
+
+ if (us->Sock != NULL)
+ {
+ if (us->ErrorDebugDisplayed == false)
+ {
+ Debug("Ok.\n");
+ }
+ else
+ {
+ Debug("Opening UDP Port %u at %s ...", us->Port, ipstr);
+ Debug("Ok.\n");
+ }
+ JoinSockToSockEvent(us->Sock, u->Event);
+
+ us->ErrorDebugDisplayed = false;
+ }
+ else
+ {
+ if (us->ErrorDebugDisplayed == false)
+ {
+ Debug("Error.\n");
+ }
+
+ us->ErrorDebugDisplayed = true;
+ }
+ }
+ }
+
+ FreeHostIPAddressList(iplist);
+
+ ReleaseList(del_us_list);
+
+ if (CompareBuf(ip_list_buf, ip_list_buf_new) == false)
+ {
+ u->HostIPAddressListChanged = true;
+ }
+
+ FreeBuf(ip_list_buf);
+ ip_list_buf = ip_list_buf_new;
+ }
+
+LABEL_RESTART:
+
+ stage_changed = false;
+
+ recv_list = NewListFast(NULL);
+
+ if (u->PollMyIpAndPort)
+ {
+ // Create a thread to get a NAT-T IP address if necessary
+ if (u->GetNatTIpThread == NULL)
+ {
+ char natt_hostname[MAX_SIZE];
+
+ RUDPGetRegisterHostNameByIP(natt_hostname, sizeof(natt_hostname), NULL);
+
+ u->GetNatTIpThread = NewQueryIpThread(natt_hostname, QUERYIPTHREAD_INTERVAL_LAST_OK, QUERYIPTHREAD_INTERVAL_LAST_NG);
+ }
+
+ GetQueryIpThreadResult(u->GetNatTIpThread, &nat_t_ip);
+ }
+
+ // Receive the data that is arriving at the socket
+ for (k = 0;k < LIST_NUM(u->SockList);k++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, k);
+
+ if (us->Sock != NULL)
+ {
+ UINT num_ignore_errors = 0;
+
+ if (u->PollMyIpAndPort && IsZeroIP(&nat_t_ip) == false && IsIP4(&us->IpAddress))
+ {
+ if (us->NextMyIpAndPortPollTick == 0 || us->NextMyIpAndPortPollTick <= now)
+ {
+ UCHAR c = 'A';
+
+ // Examine the self IP address and the self port number by using NAT-T server
+ us->NextMyIpAndPortPollTick = now + (UINT64)GenRandInterval(UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MIN, UDP_NAT_T_NAT_STATUS_CHECK_INTERVAL_MAX);
+
+ SendTo(us->Sock, &nat_t_ip, UDP_NAT_T_PORT, &c, 1);
+ }
+ }
+
+ while (true)
+ {
+ IP src_addr;
+ UINT src_port;
+ UDPPACKET *p;
+
+ UINT size = RecvFrom(us->Sock, &src_addr, &src_port, buf, buf_size);
+ if (size == 0)
+ {
+ // Socket failure
+ if (us->Sock->IgnoreRecvErr == false)
+ {
+LABEL_FATAL_ERROR:
+ Debug("RecvFrom has Error.\n");
+ us->HasError = true;
+ }
+ else
+ {
+ if ((num_ignore_errors++) >= MAX_NUM_IGNORE_ERRORS)
+ {
+ goto LABEL_FATAL_ERROR;
+ }
+ }
+ break;
+ }
+ else if (size == SOCK_LATER)
+ {
+ // No packet
+ break;
+ }
+ //Debug("UDP %u\n", size);
+
+ if (src_port == UDP_NAT_T_PORT && CmpIpAddr(&src_addr, &nat_t_ip) == 0)
+ {
+ // Receive a packet in which the IP address and the port number are written from the NAT-T server
+ if (size >= 8)
+ {
+ IP my_ip;
+ UINT my_port;
+
+ if (RUDPParseIPAndPortStr(buf, size, &my_ip, &my_port))
+ {
+ Copy(&us->PublicIpAddress, &my_ip, sizeof(IP));
+ us->PublicPort = my_port;
+ }
+ }
+ }
+ else
+ {
+ // Receive a regular packet
+ p = NewUdpPacket(&src_addr, src_port, &us->Sock->LocalIP, us->Sock->LocalPort,
+ Clone(buf, size), size);
+
+ if (p->SrcPort == MAKE_SPECIAL_PORT(52))
+ {
+ p->SrcPort = p->DestPort = MAKE_SPECIAL_PORT(50);
+ }
+
+ Add(recv_list, p);
+ }
+
+ stage_changed = true;
+ }
+ }
+ }
+
+ // Pass the received packet to the procedure
+ u->RecvProc(u, recv_list);
+
+ // Release the packet
+ for (i = 0;i < LIST_NUM(recv_list);i++)
+ {
+ UDPPACKET *p = LIST_DATA(recv_list, i);
+
+ FreeUdpPacket(p);
+ }
+
+ ReleaseList(recv_list);
+
+ cont_flag = true;
+
+ do
+ {
+ // When there are packets to be transmitted, transmit it
+ LockList(u->SendPacketList);
+ {
+ UDPLISTENER_SOCK *last_us = NULL;
+ IP last_src_ip;
+ UINT last_src_port;
+
+ Zero(&last_src_ip, sizeof(IP));
+ last_src_port = 0;
+
+ for (i = 0;i < LIST_NUM(u->SendPacketList);i++)
+ {
+ UDPPACKET *p = LIST_DATA(u->SendPacketList, i);
+ UDPLISTENER_SOCK *us;
+
+ if (last_us != NULL && last_src_port == p->SrcPort && CmpIpAddr(&last_src_ip, &p->SrcIP) == 0)
+ {
+ us = last_us;
+ }
+ else
+ {
+ // Search for a good interface for the transmission
+ us = DetermineUdpSocketForSending(u, p);
+
+ if (us != NULL)
+ {
+ last_us = us;
+ last_src_port = p->SrcPort;
+ Copy(&last_src_ip, &p->SrcIP, sizeof(IP));
+ }
+ }
+
+ if (us != NULL)
+ {
+ // Send
+ UINT ret = SendTo(us->Sock, &p->DstIP, p->DestPort, p->Data, p->Size);
+
+ if (ret == 0)
+ {
+ if (us->Sock->IgnoreSendErr == false)
+ {
+ // Socket failure
+ Debug("SendTo has Error.\n");
+ us->HasError = true;
+ last_us = NULL;
+ }
+ }
+ else
+ {
+ if (ret != SOCK_LATER)
+ {
+ stage_changed = true;
+ }
+ }
+ }
+
+ FreeUdpPacket(p);
+ }
+ DeleteAll(u->SendPacketList);
+ }
+ UnlockList(u->SendPacketList);
+
+ if (LIST_NUM(u->SendPacketList) == 0)
+ {
+ cont_flag = false;
+ }
+ }
+ while (cont_flag);
+
+ if (stage_changed && u->Halt == false)
+ {
+ goto LABEL_RESTART;
+ }
+
+ // Timing adjustment
+ interval = GetNextIntervalForInterrupt(u->Interrupts);
+
+ if (interval == INFINITE)
+ {
+ interval = UDPLISTENER_WAIT_INTERVAL;
+ }
+ else
+ {
+ interval = MIN(UDPLISTENER_WAIT_INTERVAL, interval);
+ }
+
+ if (interval >= 1)
+ {
+ WaitSockEvent(u->Event, interval);
+ }
+ }
+
+ if (u->GetNatTIpThread != NULL)
+ {
+ FreeQueryIpThread(u->GetNatTIpThread);
+ }
+
+ // Release of the socket list
+ for (i = 0;i < LIST_NUM(u->SockList);i++)
+ {
+ UDPLISTENER_SOCK *us = (UDPLISTENER_SOCK *)LIST_DATA(u->SockList, i);
+
+ Disconnect(us->Sock);
+ ReleaseSock(us->Sock);
+
+ Free(us);
+ }
+ ReleaseList(u->SockList);
+
+ FreeBuf(ip_list_buf);
+
+ Free(buf);
+}
+
+// Select the best UDP socket to be used for transmission
+UDPLISTENER_SOCK *DetermineUdpSocketForSending(UDPLISTENER *u, UDPPACKET *p)
+{
+ UINT i;
+ // Validate arguments
+ if (u == NULL || p == NULL)
+ {
+ return NULL;
+ }
+
+ for (i = 0;i < LIST_NUM(u->SockList);i++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i);
+
+ if (us->Sock != NULL && us->HasError == false)
+ {
+ if (us->Port == p->SrcPort)
+ {
+ if (CmpIpAddr(&us->IpAddress, &p->SrcIP) == 0)
+ {
+ return us;
+ }
+ }
+ }
+ }
+
+ for (i = 0;i < LIST_NUM(u->SockList);i++)
+ {
+ UDPLISTENER_SOCK *us = LIST_DATA(u->SockList, i);
+
+ if (us->Sock != NULL && us->HasError == false)
+ {
+ if (us->Port == p->SrcPort)
+ {
+ if (IsZeroIP(&us->IpAddress))
+ {
+ if ((IsIP4(&p->DstIP) && IsIP4(&us->IpAddress)) ||
+ (IsIP6(&p->DstIP) && IsIP6(&us->IpAddress)))
+ {
+ return us;
+ }
+ }
+ }
+ }
+ }
+
+ return NULL;
+}
+
+// Release of the UDP packet
+void FreeUdpPacket(UDPPACKET *p)
+{
+ // Validate arguments
+ if (p == NULL)
+ {
+ return;
+ }
+
+ Free(p->Data);
+ Free(p);
+}
+
+// Create a new UDP packet
+UDPPACKET *NewUdpPacket(IP *src_ip, UINT src_port, IP *dst_ip, UINT dst_port, void *data, UINT size)
+{
+ UDPPACKET *p;
+ // Validate arguments
+ if (data == NULL || size == 0 || dst_ip == NULL || dst_port == 0)
+ {
+ return NULL;
+ }
+
+ p = ZeroMalloc(sizeof(UDPPACKET));
+
+ p->Data = data;
+ p->Size = size;
+
+ Copy(&p->SrcIP, src_ip, sizeof(IP));
+ p->SrcPort = src_port;
+
+ Copy(&p->DstIP, dst_ip, sizeof(IP));
+ p->DestPort = dst_port;
+
+ return p;
+}
+
+// Transmit the packets via UDP Listener
+void UdpListenerSendPackets(UDPLISTENER *u, LIST *packet_list)
+{
+ UINT num = 0;
+ // Validate arguments
+ if (u == NULL || packet_list == NULL)
+ {
+ return;
+ }
+
+ LockList(u->SendPacketList);
+ {
+ UINT i;
+
+ num = LIST_NUM(packet_list);
+
+ for (i = 0;i < LIST_NUM(packet_list);i++)
+ {
+ UDPPACKET *p = LIST_DATA(packet_list, i);
+
+ Add(u->SendPacketList, p);
+ }
+ }
+ UnlockList(u->SendPacketList);
+
+ if (num >= 1)
+ {
+ SetSockEvent(u->Event);
+ }
+}
+void UdpListenerSendPacket(UDPLISTENER *u, UDPPACKET *packet)
+{
+ LIST *o;
+ // Validate arguments
+ if (u == NULL || packet == NULL)
+ {
+ return;
+ }
+
+ o = NewListFast(NULL);
+ Add(o, packet);
+
+ UdpListenerSendPackets(u, o);
+
+ ReleaseList(o);
+}
+
+// Creating a UDP listener
+UDPLISTENER *NewUdpListener(UDPLISTENER_RECV_PROC *recv_proc, void *param)
+{
+ UDPLISTENER *u;
+ // Validate arguments
+ if (recv_proc == NULL)
+ {
+ return NULL;
+ }
+
+ u = ZeroMalloc(sizeof(UDPLISTENER));
+
+ u->Param = param;
+
+ u->PortList = NewList(NULL);
+ u->Event = NewSockEvent();
+
+ u->RecvProc = recv_proc;
+ u->SendPacketList = NewList(NULL);
+
+ u->Interrupts = NewInterruptManager();
+
+ u->Thread = NewThread(UdpListenerThread, u);
+
+ return u;
+}
+
+// Release the UDP listener
+void FreeUdpListener(UDPLISTENER *u)
+{
+ UINT i;
+ // Validate arguments
+ if (u == NULL)
+ {
+ return;
+ }
+
+ u->Halt = true;
+ SetSockEvent(u->Event);
+
+ WaitThread(u->Thread, INFINITE);
+ ReleaseThread(u->Thread);
+ ReleaseSockEvent(u->Event);
+
+ ReleaseIntList(u->PortList);
+
+ for (i = 0;i < LIST_NUM(u->SendPacketList);i++)
+ {
+ UDPPACKET *p = LIST_DATA(u->SendPacketList, i);
+
+ FreeUdpPacket(p);
+ }
+
+ ReleaseList(u->SendPacketList);
+
+ FreeInterruptManager(u->Interrupts);
+
+ Free(u);
+}
+
+// Add the UDP port
+void AddPortToUdpListener(UDPLISTENER *u, UINT port)
+{
+ // Validate arguments
+ if (u == NULL || port == 0)
+ {
+ return;
+ }
+
+ LockList(u->PortList);
+ {
+ AddIntDistinct(u->PortList, port);
+ }
+ UnlockList(u->PortList);
+
+ SetSockEvent(u->Event);
+}
+
+// Get the port list
+UINT GetUdpListenerPortList(UDPLISTENER *u, UINT **port_list)
+{
+ UINT num_ports;
+ // Validate arguments
+ if (u == NULL || port_list == NULL)
+ {
+ return 0;
+ }
+
+ LockList(u->PortList);
+ {
+ UINT *ports;
+ UINT i;
+
+ num_ports = LIST_NUM(u->PortList);
+ ports = ZeroMalloc(sizeof(UINT) * num_ports);
+
+ for (i = 0;i < num_ports;i++)
+ {
+ ports[i] = *((UINT *)(LIST_DATA(u->PortList, i)));
+ }
+
+ *port_list = ports;
+ }
+ UnlockList(u->PortList);
+
+ return num_ports;
+}
+
+// Dekete all the UDP ports
+void DeleteAllPortFromUdpListener(UDPLISTENER *u)
+{
+ // Validate arguments
+ if (u == NULL)
+ {
+ return;
+ }
+
+ LockList(u->PortList);
+ {
+ UINT num_ports = LIST_NUM(u->PortList);
+ UINT *ports = ZeroMalloc(sizeof(UINT) * num_ports);
+ UINT i;
+
+ for (i = 0;i < num_ports;i++)
+ {
+ ports[i] = *((UINT *)(LIST_DATA(u->PortList, i)));
+ }
+
+ for (i = 0;i < num_ports;i++)
+ {
+ UINT port = ports[i];
+
+ DelInt(u->PortList, port);
+ }
+
+ Free(ports);
+ }
+ UnlockList(u->PortList);
+
+ SetSockEvent(u->Event);
+}
+
+// Delete the UDP port
+void DeletePortFromUdpListener(UDPLISTENER *u, UINT port)
+{
+ // Validate arguments
+ if (u == NULL || port == 0)
+ {
+ return;
+ }
+
+ LockList(u->PortList);
+ {
+ DelInt(u->PortList, port);
+ }
+ UnlockList(u->PortList);
+
+ SetSockEvent(u->Event);
+}
+
+// Sort function of the interrupt management list
+int CmpInterruptManagerTickList(void *p1, void *p2)
+{
+ UINT64 *v1, *v2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+
+ v1 = *(UINT64 **)p1;
+ v2 = *(UINT64 **)p2;
+ if (v1 == NULL || v2 == NULL)
+ {
+ return 0;
+ }
+
+ if (*v1 > *v2)
+ {
+ return 1;
+ }
+ else if (*v1 < *v2)
+ {
+ return -1;
+ }
+ else
+ {
+ return 0;
+ }
+}
+
+// Initialization of the interrupt management
+INTERRUPT_MANAGER *NewInterruptManager()
+{
+ INTERRUPT_MANAGER *m = ZeroMalloc(sizeof(INTERRUPT_MANAGER));
+
+ m->TickList = NewList(CmpInterruptManagerTickList);
+
+ return m;
+}
+
+// Release of the interrupt management
+void FreeInterruptManager(INTERRUPT_MANAGER *m)
+{
+ UINT i;
+ // Validate arguments
+ if (m == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(m->TickList);i++)
+ {
+ UINT64 *v = LIST_DATA(m->TickList, i);
+
+ Free(v);
+ }
+
+ ReleaseList(m->TickList);
+
+ Free(m);
+}
+
+// Add a number to the interrupt management
+void AddInterrupt(INTERRUPT_MANAGER *m, UINT64 tick)
+{
+ // Validate arguments
+ if (tick == 0)
+ {
+ return;
+ }
+
+ LockList(m->TickList);
+ {
+ if (Search(m->TickList, &tick) == NULL)
+ {
+ Insert(m->TickList, Clone(&tick, sizeof(UINT64)));
+ }
+ }
+ UnlockList(m->TickList);
+}
+
+// Get the interval to the next calling
+UINT GetNextIntervalForInterrupt(INTERRUPT_MANAGER *m)
+{
+ UINT ret = INFINITE;
+ UINT i;
+ LIST *o = NULL;
+ UINT64 now = Tick64();
+ // Validate arguments
+ if (m == NULL)
+ {
+ return 0;
+ }
+
+ LockList(m->TickList);
+ {
+ // Remove entries older than now already
+ for (i = 0;i < LIST_NUM(m->TickList);i++)
+ {
+ UINT64 *v = LIST_DATA(m->TickList, i);
+
+ if (now >= *v)
+ {
+ ret = 0;
+
+ if (o == NULL)
+ {
+ o = NewListFast(NULL);
+ }
+
+ Add(o, v);
+ }
+ else
+ {
+ break;
+ }
+ }
+
+ for (i = 0;i < LIST_NUM(o);i++)
+ {
+ UINT64 *v = LIST_DATA(o, i);
+
+ Free(v);
+
+ Delete(m->TickList, v);
+ }
+
+ if (o != NULL)
+ {
+ ReleaseList(o);
+ }
+
+ if (ret == INFINITE)
+ {
+ if (LIST_NUM(m->TickList) >= 1)
+ {
+ UINT64 *v = LIST_DATA(m->TickList, 0);
+
+ ret = (UINT)(*v - now);
+ }
+ }
+ }
+ UnlockList(m->TickList);
+
+ return ret;
+}
+
+// Let that the listening socket for the reverse socket to accept the new socket
+void InjectNewReverseSocketToAccept(SOCK *listen_sock, SOCK *s, IP *client_ip, UINT client_port)
+{
+ bool ok = false;
+ // Validate arguments
+ if (listen_sock == NULL || s == NULL)
+ {
+ return;
+ }
+
+ LockQueue(listen_sock->ReverseAcceptQueue);
+ {
+ if (listen_sock->CancelAccept == false && listen_sock->Disconnecting == false)
+ {
+ InsertQueue(listen_sock->ReverseAcceptQueue, s);
+
+ ok = true;
+
+ s->ServerMode = true;
+ s->IsReverseAcceptedSocket = true;
+
+ Copy(&s->RemoteIP, client_ip, sizeof(IP));
+ s->RemotePort = client_port;
+ }
+ }
+ UnlockQueue(listen_sock->ReverseAcceptQueue);
+
+ if (ok == false)
+ {
+ Disconnect(s);
+ ReleaseSock(s);
+ }
+ else
+ {
+ Set(listen_sock->ReverseAcceptEvent);
+ }
+}
+
+// Create a listening socket for the reverse socket
+SOCK *ListenReverse()
+{
+ SOCK *s = NewSock();
+
+ s->Type = SOCK_REVERSE_LISTEN;
+ s->ListenMode = true;
+ s->ReverseAcceptQueue = NewQueue();
+ s->ReverseAcceptEvent = NewEvent();
+ s->Connected = true;
+
+ return s;
+}
+
+// Accept on the reverse socket
+SOCK *AcceptReverse(SOCK *s)
+{
+ // Validate arguments
+ if (s == NULL || s->Type != SOCK_REVERSE_LISTEN || s->ListenMode == false)
+ {
+ return NULL;
+ }
+
+ while (true)
+ {
+ SOCK *ret;
+ if (s->Disconnecting || s->CancelAccept)
+ {
+ return NULL;
+ }
+
+ LockQueue(s->ReverseAcceptQueue);
+ {
+ ret = GetNext(s->ReverseAcceptQueue);
+ }
+ UnlockQueue(s->ReverseAcceptQueue);
+
+ if (ret != NULL)
+ {
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_AZURE);
+
+ return ret;
+ }
+
+ Wait(s->ReverseAcceptEvent, INFINITE);
+ }
+}
+
+// Start listening on the in-process socket
+SOCK *ListenInProc()
+{
+ SOCK *s = NewSock();
+
+ s->Type = SOCK_INPROC;
+ s->ListenMode = true;
+ s->InProcAcceptQueue = NewQueue();
+ s->InProcAcceptEvent = NewEvent();
+ s->Connected = true;
+
+ return s;
+}
+
+// Accept at the in-process socket
+SOCK *AcceptInProc(SOCK *s)
+{
+ // Validate arguments
+ if (s == NULL || s->Type != SOCK_INPROC || s->ListenMode == false)
+ {
+ return NULL;
+ }
+
+ while (true)
+ {
+ SOCK *ret;
+ if (s->Disconnecting || s->CancelAccept)
+ {
+ return NULL;
+ }
+
+ LockQueue(s->InProcAcceptQueue);
+ {
+ ret = GetNext(s->InProcAcceptQueue);
+ }
+ UnlockQueue(s->InProcAcceptQueue);
+
+ if (ret != NULL)
+ {
+ StrCpy(ret->UnderlayProtocol, sizeof(ret->UnderlayProtocol), SOCK_UNDERLAY_INPROC);
+
+ return ret;
+ }
+
+ Wait(s->InProcAcceptEvent, INFINITE);
+ }
+}
+
+// Connect by the in-process socket
+SOCK *ConnectInProc(SOCK *listen_sock, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port)
+{
+ SOCK *ss, *sc;
+ bool ok = false;
+ // Validate arguments
+ if (listen_sock == NULL || listen_sock->Type != SOCK_INPROC || listen_sock->ListenMode == false)
+ {
+ return NULL;
+ }
+
+ NewSocketPair(&sc, &ss, client_ip, client_port, server_ip, server_port);
+
+ LockQueue(listen_sock->InProcAcceptQueue);
+ {
+ if (listen_sock->CancelAccept == false && listen_sock->Disconnecting == false)
+ {
+ InsertQueue(listen_sock->InProcAcceptQueue, ss);
+
+ ok = true;
+ }
+ }
+ UnlockQueue(listen_sock->InProcAcceptQueue);
+
+ if (ok == false)
+ {
+ ReleaseSock(ss);
+ ReleaseSock(sc);
+ return NULL;
+ }
+
+ Set(listen_sock->InProcAcceptEvent);
+
+ return sc;
+}
+
+// Creating a new socket pair
+void NewSocketPair(SOCK **client, SOCK **server, IP *client_ip, UINT client_port, IP *server_ip, UINT server_port)
+{
+ IP iptmp;
+ TUBE *t1, *t2;
+ SOCK *sc, *ss;
+ SOCK_EVENT *e1, *e2;
+ // Validate arguments
+ if (client == NULL || server == NULL)
+ {
+ return;
+ }
+
+ SetIP(&iptmp, 127, 0, 0, 1);
+ if (client_ip == NULL)
+ {
+ client_ip = &iptmp;
+ }
+ if (server_ip == NULL)
+ {
+ server_ip = &iptmp;
+ }
+
+ // Creating a tube
+ NewTubePair(&t1, &t2, 0); // t1: C -> S, t2: S -> C
+
+ // Creating a socket event
+ e1 = NewSockEvent();
+ e2 = NewSockEvent();
+
+ SetTubeSockEvent(t1, e1);
+ SetTubeSockEvent(t2, e2);
+
+ sc = NewInProcSocket(t1, t2);
+ ss = NewInProcSocket(t2, t1);
+
+ Copy(&sc->LocalIP, client_ip, sizeof(IP));
+ sc->LocalPort = client_port;
+ Copy(&sc->RemoteIP, server_ip, sizeof(IP));
+ sc->RemotePort = server_port;
+
+ Copy(&ss->LocalIP, server_ip, sizeof(IP));
+ ss->LocalPort = server_port;
+ Copy(&ss->RemoteIP, client_ip, sizeof(IP));
+ ss->RemotePort = client_port;
+
+ sc->Connected = true;
+ sc->ServerMode = false;
+
+ ss->Connected = true;
+ ss->ServerMode = true;
+
+ SetTimeout(sc, INFINITE);
+ SetTimeout(ss, INFINITE);
+
+ QuerySocketInformation(sc);
+ QuerySocketInformation(ss);
+
+ ReleaseSockEvent(e1);
+ ReleaseSockEvent(e2);
+
+ ReleaseTube(t1);
+ ReleaseTube(t2);
+
+ *client = sc;
+ *server = ss;
+}
+
+// Creating a new in-process socket
+SOCK *NewInProcSocket(TUBE *tube_send, TUBE *tube_recv)
+{
+ SOCK *s;
+ // Validate arguments
+ if (tube_recv == NULL || tube_send == NULL)
+ {
+ return NULL;
+ }
+
+ s = NewSock();
+
+ s->Type = SOCK_INPROC;
+
+ s->SendTube = tube_send;
+ s->RecvTube = tube_recv;
+
+ AddRef(tube_send->Ref);
+ AddRef(tube_recv->Ref);
+
+ s->InProcRecvFifo = NewFifo();
+
+ s->Connected = true;
+
+ return s;
+}
+
+// Transmission process for the in-process socket
+UINT SendInProc(SOCK *sock, void *data, UINT size)
+{
+ if (sock == NULL || sock->Type != SOCK_INPROC || sock->Disconnecting || sock->Connected == false)
+ {
+ return 0;
+ }
+
+ if (IsTubeConnected(sock->SendTube) == false)
+ {
+ return 0;
+ }
+
+ if (TubeSend(sock->SendTube, data, size, NULL) == false)
+ {
+ return 0;
+ }
+
+ return size;
+}
+
+// Receiving process for the in-process socket
+UINT RecvInProc(SOCK *sock, void *data, UINT size)
+{
+ FIFO *f;
+ UINT ret;
+ UINT timeout;
+ UINT64 giveup_time;
+ TUBEDATA *d = NULL;
+ if (sock == NULL || sock->Type != SOCK_INPROC || sock->Disconnecting || sock->Connected == false)
+ {
+ return 0;
+ }
+
+ if (IsTubeConnected(sock->SendTube) == false)
+ {
+ return 0;
+ }
+
+ f = sock->InProcRecvFifo;
+ if (f == NULL)
+ {
+ return 0;
+ }
+
+ // If there is data in the FIFO, return it immediately
+ ret = ReadFifo(f, data, size);
+ if (ret != 0)
+ {
+ return ret;
+ }
+
+ timeout = GetTimeout(sock);
+
+ giveup_time = Tick64() + (UINT)timeout;
+
+ // When there is no data in the FIFO, read the next data from the tube
+ d = NULL;
+
+ while (true)
+ {
+ UINT64 now = 0;
+ UINT interval;
+
+ if (sock->AsyncMode == false)
+ {
+ now = Tick64();
+
+ if (now >= giveup_time)
+ {
+ break;
+ }
+ }
+
+ d = TubeRecvAsync(sock->RecvTube);
+
+ if (d != NULL)
+ {
+ break;
+ }
+
+ if (IsTubeConnected(sock->RecvTube) == false)
+ {
+ break;
+ }
+
+ if (sock->AsyncMode)
+ {
+ break;
+ }
+
+ interval = (UINT)(giveup_time - now);
+
+ Wait(sock->RecvTube->Event, interval);
+ }
+
+ if (d == NULL)
+ {
+ if (IsTubeConnected(sock->RecvTube) == false)
+ {
+ return 0;
+ }
+
+ if (sock->AsyncMode == false)
+ {
+ // If a timeout occurs in synchronous mode, disconnect ir
+ Disconnect(sock);
+
+ return 0;
+ }
+ else
+ {
+ // If a timeout occurs in asynchronous mode, returns the blocking error
+ return SOCK_LATER;
+ }
+ }
+ else
+ {
+ // If the received data is larger than the requested size, write the rest to FIFO
+ if (d->DataSize > size)
+ {
+ WriteFifo(f, ((UCHAR *)d->Data) + size, d->DataSize - size);
+ ret = size;
+ }
+ else
+ {
+ ret = d->DataSize;
+ }
+
+ Copy(data, d->Data, ret);
+
+ FreeTubeData(d);
+
+ return ret;
+ }
+}
+
+// Wait for the arrival of data on multiple tubes
+void WaitForTubes(TUBE **tubes, UINT num, UINT timeout)
+{
+ // Validate arguments
+ if (num != 0 && tubes == NULL)
+ {
+ return;
+ }
+ if (timeout == 0)
+ {
+ return;
+ }
+ if (num == 0)
+ {
+ SleepThread(timeout);
+ return;
+ }
+
+#ifdef OS_WIN32
+ Win32WaitForTubes(tubes, num, timeout);
+#else // OS_WIN32
+ UnixWaitForTubes(tubes, num, timeout);
+#endif // OS_WIN32
+}
+
+#ifdef OS_WIN32
+void Win32WaitForTubes(TUBE **tubes, UINT num, UINT timeout)
+{
+ HANDLE array[MAXIMUM_WAIT_OBJECTS];
+ UINT i;
+
+ Zero(array, sizeof(array));
+
+ for (i = 0;i < num;i++)
+ {
+ TUBE *t = tubes[i];
+
+ array[i] = t->Event->pData;
+ }
+
+ if (num == 1)
+ {
+ WaitForSingleObject(array[0], timeout);
+ }
+ else
+ {
+ WaitForMultipleObjects(num, array, false, timeout);
+ }
+}
+#else // OS_WIN32
+void UnixWaitForTubes(TUBE **tubes, UINT num, UINT timeout)
+{
+ int *fds;
+ UINT i;
+ char tmp[MAX_SIZE];
+ bool any_of_tubes_are_readable = false;
+
+ fds = ZeroMalloc(sizeof(int) * num);
+
+ for (i = 0;i < num;i++)
+ {
+ fds[i] = tubes[i]->SockEvent->pipe_read;
+
+ if (tubes[i]->SockEvent->current_pipe_data != 0)
+ {
+ any_of_tubes_are_readable = true;
+ }
+ }
+
+ if (any_of_tubes_are_readable == false)
+ {
+ UnixSelectInner(num, fds, 0, NULL, timeout);
+ }
+
+ for (i = 0;i < num;i++)
+ {
+ int fd = fds[i];
+ int readret;
+
+ tubes[i]->SockEvent->current_pipe_data = 0;
+
+ do
+ {
+ readret = read(fd, tmp, sizeof(tmp));
+ }
+ while (readret >= 1);
+ }
+
+ Free(fds);
+}
+#endif // OS_WIN32
+
+// Creating a Tube Flush List
+TUBE_FLUSH_LIST *NewTubeFlushList()
+{
+ TUBE_FLUSH_LIST *f = ZeroMalloc(sizeof(TUBE_FLUSH_LIST));
+
+ f->List = NewListFast(NULL);
+
+ return f;
+}
+
+// Release of the Tube Flush List
+void FreeTubeFlushList(TUBE_FLUSH_LIST *f)
+{
+ UINT i;
+ // Validate arguments
+ if (f == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(f->List);i++)
+ {
+ TUBE *t = LIST_DATA(f->List, i);
+
+ ReleaseTube(t);
+ }
+
+ ReleaseList(f->List);
+
+ Free(f);
+}
+
+// Add a Tube to the Tube Flush List
+void AddTubeToFlushList(TUBE_FLUSH_LIST *f, TUBE *t)
+{
+ // Validate arguments
+ if (f == NULL || t == NULL)
+ {
+ return;
+ }
+
+ if (t->IsInFlushList)
+ {
+ return;
+ }
+
+ if (IsInList(f->List, t) == false)
+ {
+ Add(f->List, t);
+
+ AddRef(t->Ref);
+
+ t->IsInFlushList = true;
+ }
+}
+
+// Flush the all tubes in the Tube Flush List
+void FlushTubeFlushList(TUBE_FLUSH_LIST *f)
+{
+ UINT i;
+ // Validate arguments
+ if (f == NULL)
+ {
+ return;
+ }
+
+ for (i = 0;i < LIST_NUM(f->List);i++)
+ {
+ TUBE *t = LIST_DATA(f->List, i);
+
+ TubeFlush(t);
+ t->IsInFlushList = false;
+
+ ReleaseTube(t);
+ }
+
+ DeleteAll(f->List);
+}
+
+// The server receives a PACK from the client
+PACK *HttpServerRecv(SOCK *s)
+{
+ BUF *b;
+ PACK *p;
+ HTTP_HEADER *h;
+ UINT size;
+ UCHAR *tmp;
+ HTTP_VALUE *v;
+ UINT num_noop = 0;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return NULL;
+ }
+
+START:
+
+ h = RecvHttpHeader(s);
+ if (h == NULL)
+ {
+ goto BAD_REQUEST;
+ }
+
+ if (StrCmpi(h->Method, "POST") != 0 ||
+ StrCmpi(h->Target, HTTP_VPN_TARGET) != 0 ||
+ StrCmpi(h->Version, "HTTP/1.1") != 0)
+ {
+ FreeHttpHeader(h);
+ goto BAD_REQUEST;
+ }
+
+ v = GetHttpValue(h, "Content-Type");
+ if (v == NULL || StrCmpi(v->Data, HTTP_CONTENT_TYPE2) != 0)
+ {
+ FreeHttpHeader(h);
+ goto BAD_REQUEST;
+ }
+
+ size = GetContentLength(h);
+ if (size == 0 || size > HTTP_PACK_MAX_SIZE)
+ {
+ FreeHttpHeader(h);
+ goto BAD_REQUEST;
+ }
+
+ tmp = MallocEx(size, true);
+ if (RecvAll(s, tmp, size, s->SecureMode) == false)
+ {
+ Free(tmp);
+ FreeHttpHeader(h);
+ return NULL;
+ }
+
+ b = NewBuf();
+ WriteBuf(b, tmp, size);
+ Free(tmp);
+ FreeHttpHeader(h);
+
+ SeekBuf(b, 0, 0);
+ p = BufToPack(b);
+ FreeBuf(b);
+
+ // Determine whether it's a NOOP
+ if (PackGetInt(p, "noop") != 0)
+ {
+ Debug("recv: noop\n");
+ FreePack(p);
+
+ p = PackError(0);
+ PackAddInt(p, "noop", 1);
+ if (HttpServerSend(s, p) == false)
+ {
+ FreePack(p);
+ return NULL;
+ }
+
+ FreePack(p);
+
+ num_noop++;
+
+ if (num_noop > MAX_NOOP_PER_SESSION)
+ {
+ return NULL;
+ }
+
+ goto START;
+ }
+
+ return p;
+
+BAD_REQUEST:
+ // Return an error
+
+
+ return NULL;
+}
+
+// Store the error value into PACK
+PACK *PackError(UINT error)
+{
+ PACK *p;
+
+ p = NewPack();
+ PackAddInt(p, "error", error);
+
+ return p;
+}
+
+// Get the error value from PACK
+UINT GetErrorFromPack(PACK *p)
+{
+ // Validate arguments
+ if (p == NULL)
+ {
+ return 0;
+ }
+
+ return PackGetInt(p, "error");
+}
+
+// Client receives a PACK from the server
+PACK *HttpClientRecv(SOCK *s)
+{
+ BUF *b;
+ PACK *p;
+ HTTP_HEADER *h;
+ UINT size;
+ UCHAR *tmp;
+ HTTP_VALUE *v;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return NULL;
+ }
+
+ h = RecvHttpHeader(s);
+ if (h == NULL)
+ {
+ return NULL;
+ }
+
+ if (StrCmpi(h->Method, "HTTP/1.1") != 0 ||
+ StrCmpi(h->Target, "200") != 0)
+ {
+ FreeHttpHeader(h);
+ return NULL;
+ }
+
+ v = GetHttpValue(h, "Content-Type");
+ if (v == NULL || StrCmpi(v->Data, HTTP_CONTENT_TYPE2) != 0)
+ {
+ FreeHttpHeader(h);
+ return NULL;
+ }
+
+ size = GetContentLength(h);
+ if (size == 0 || size > MAX_PACK_SIZE)
+ {
+ FreeHttpHeader(h);
+ return NULL;
+ }
+
+ tmp = MallocEx(size, true);
+ if (RecvAll(s, tmp, size, s->SecureMode) == false)
+ {
+ Free(tmp);
+ FreeHttpHeader(h);
+ return NULL;
+ }
+
+ b = NewBuf();
+ WriteBuf(b, tmp, size);
+ Free(tmp);
+ FreeHttpHeader(h);
+
+ SeekBuf(b, 0, 0);
+ p = BufToPack(b);
+ FreeBuf(b);
+
+ return p;
+}
+
+// Create an entry to PACK for the dummy
+void CreateDummyValue(PACK *p)
+{
+ UINT size;
+ UCHAR *buf;
+ // Validate arguments
+ if (p == NULL)
+ {
+ return;
+ }
+
+ size = Rand32() % HTTP_PACK_RAND_SIZE_MAX;
+ buf = Malloc(size);
+ Rand(buf, size);
+
+ PackAddData(p, "pencore", buf, size);
+
+ Free(buf);
+}
+
+// Client send a PACK to the server
+bool HttpClientSend(SOCK *s, PACK *p)
+{
+ BUF *b;
+ bool ret;
+ HTTP_HEADER *h;
+ char date_str[MAX_SIZE];
+ // Validate arguments
+ if (s == NULL || p == NULL)
+ {
+ return false;
+ }
+
+ CreateDummyValue(p);
+
+ b = PackToBuf(p);
+ if (b == NULL)
+ {
+ return false;
+ }
+
+ h = NewHttpHeader("POST", HTTP_VPN_TARGET, "HTTP/1.1");
+
+ GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
+ AddHttpValue(h, NewHttpValue("Date", date_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE2));
+
+ ret = PostHttp(s, h, b->Buf, b->Size);
+
+ FreeHttpHeader(h);
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Server sends a PACK to the client
+bool HttpServerSend(SOCK *s, PACK *p)
+{
+ BUF *b;
+ bool ret;
+ HTTP_HEADER *h;
+ char date_str[MAX_SIZE];
+ // Validate arguments
+ if (s == NULL || p == NULL)
+ {
+ return false;
+ }
+
+ CreateDummyValue(p);
+
+ b = PackToBuf(p);
+ if (b == NULL)
+ {
+ return false;
+ }
+
+ h = NewHttpHeader("HTTP/1.1", "200", "OK");
+
+ GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
+ AddHttpValue(h, NewHttpValue("Date", date_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE2));
+
+ ret = PostHttp(s, h, b->Buf, b->Size);
+
+ FreeHttpHeader(h);
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Replace unsafe characters in target
+void ReplaceUnsafeCharInTarget(char *target){
+ UINT i;
+ for(i = 0; target[i] ; i++) {
+ if(target[i] == '<')
+ target[i] = '(';
+ else if(target[i] == '>')
+ target[i] = ')';
+ }
+}
+
+// Sending the 501 Not Implemented error
+bool HttpSendNotImplemented(SOCK *s, char *method, char *target, char *version)
+{
+ HTTP_HEADER *h;
+ char date_str[MAX_SIZE];
+ char *str;
+ UINT str_size;
+ char port_str[MAX_SIZE];
+ bool ret;
+ char host[MAX_SIZE];
+ UINT port;
+ // Validate arguments
+ if (s == NULL || target == NULL)
+ {
+ return false;
+ }
+
+ // Get the host name
+ //GetMachineName(host, MAX_SIZE);
+ Zero(host, sizeof(host));
+ IPToStr(host, sizeof(host), &s->LocalIP);
+ // Get the port number
+ port = s->LocalPort;
+
+ // Creating a header
+ GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
+
+ h = NewHttpHeader("HTTP/1.1", "501", "Method Not Implemented");
+
+ AddHttpValue(h, NewHttpValue("Date", date_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
+
+ // Creating a Data
+ str_size = sizeof(http_501_str) * 2 + StrLen(target) + StrLen(host) + StrLen(method) + StrLen(version);
+ str = Malloc(str_size);
+ StrCpy(str, str_size, http_501_str);
+
+ // TARGET
+ ReplaceUnsafeCharInTarget(target);
+ ReplaceStri(str, str_size, str, "$TARGET$", target);
+
+ // HOST
+ ReplaceStri(str, str_size, str, "$HOST$", host);
+
+ // PORT
+ ToStr(port_str, port);
+ ReplaceStri(str, str_size, str, "$PORT$", port_str);
+
+ // METHOD
+ ReplaceStri(str, str_size, str, "$METHOD$", method);
+
+ // VERSION
+ ReplaceStri(str, str_size, str, "$VERSION$", version);
+
+ // Transmission
+ ret = PostHttp(s, h, str, StrLen(str));
+
+ FreeHttpHeader(h);
+ Free(str);
+
+ return ret;
+}
+
+// Sending a 404 Not Found error
+bool HttpSendNotFound(SOCK *s, char *target)
+{
+ HTTP_HEADER *h;
+ char date_str[MAX_SIZE];
+ char *str;
+ UINT str_size;
+ char port_str[MAX_SIZE];
+ bool ret;
+ char host[MAX_SIZE];
+ UINT port;
+ // Validate arguments
+ if (s == NULL || target == NULL)
+ {
+ return false;
+ }
+
+ // Get the host name
+ //GetMachineName(host, MAX_SIZE);
+ Zero(host, sizeof(host));
+ IPToStr(host, sizeof(host), &s->LocalIP);
+ // Get the port number
+ port = s->LocalPort;
+
+ // Creating a header
+ GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
+
+ h = NewHttpHeader("HTTP/1.1", "404", "Not Found");
+
+ AddHttpValue(h, NewHttpValue("Date", date_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
+
+ // Creating a Data
+ str_size = sizeof(http_404_str) * 2 + StrLen(target) + StrLen(host);
+ str = Malloc(str_size);
+ StrCpy(str, str_size, http_404_str);
+
+ // TARGET
+ ReplaceUnsafeCharInTarget(target);
+ ReplaceStri(str, str_size, str, "$TARGET$", target);
+
+ // HOST
+ ReplaceStri(str, str_size, str, "$HOST$", host);
+
+ // PORT
+ ToStr(port_str, port);
+ ReplaceStri(str, str_size, str, "$PORT$", port_str);
+
+ // Transmission
+ ret = PostHttp(s, h, str, StrLen(str));
+
+ FreeHttpHeader(h);
+ Free(str);
+
+ return ret;
+}
+
+// Sending a 500 Server Error
+bool HttpSendServerError(SOCK *s, char *target)
+{
+ HTTP_HEADER *h;
+ char date_str[MAX_SIZE];
+ char *str;
+ UINT str_size;
+ char port_str[MAX_SIZE];
+ bool ret;
+ char host[MAX_SIZE];
+ UINT port;
+ // Validate arguments
+ if (s == NULL || target == NULL)
+ {
+ return false;
+ }
+
+ // Get the host name
+ //GetMachineName(host, MAX_SIZE);
+ Zero(host, sizeof(host));
+ IPToStr(host, sizeof(host), &s->LocalIP);
+ // Get the port number
+ port = s->LocalPort;
+
+ // Creating a header
+ GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
+
+ h = NewHttpHeader("HTTP/1.1", "500", "Server Error");
+
+ AddHttpValue(h, NewHttpValue("Date", date_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
+
+ // Creating a Data
+ str_size = sizeof(http_500_str) * 2 + StrLen(target) + StrLen(host);
+ str = Malloc(str_size);
+ StrCpy(str, str_size, http_500_str);
+
+ // TARGET
+ ReplaceUnsafeCharInTarget(target);
+ ReplaceStri(str, str_size, str, "$TARGET$", target);
+
+ // HOST
+ ReplaceStri(str, str_size, str, "$HOST$", host);
+
+ // PORT
+ ToStr(port_str, port);
+ ReplaceStri(str, str_size, str, "$PORT$", port_str);
+
+ // Transmission
+ ret = PostHttp(s, h, str, StrLen(str));
+
+ FreeHttpHeader(h);
+ Free(str);
+
+ return ret;
+}
+
+// Sending a 403 Forbidden error
+bool HttpSendForbidden(SOCK *s, char *target, char *server_id)
+{
+ HTTP_HEADER *h;
+ char date_str[MAX_SIZE];
+ char *str;
+ UINT str_size;
+ char port_str[MAX_SIZE];
+ bool ret;
+ char host[MAX_SIZE];
+ UINT port;
+ // Validate arguments
+ if (s == NULL || target == NULL)
+ {
+ return false;
+ }
+
+ // Get the host name
+ //GetMachineName(host, MAX_SIZE);
+ Zero(host, sizeof(host));
+ IPToStr(host, sizeof(host), &s->LocalIP);
+ // Get the port number
+ port = s->LocalPort;
+
+ // Creating a header
+ GetHttpDateStr(date_str, sizeof(date_str), SystemTime64());
+
+ h = NewHttpHeader("HTTP/1.1", "403", "Forbidden");
+
+ AddHttpValue(h, NewHttpValue("Date", date_str));
+ AddHttpValue(h, NewHttpValue("Keep-Alive", HTTP_KEEP_ALIVE));
+ AddHttpValue(h, NewHttpValue("Connection", "Keep-Alive"));
+ AddHttpValue(h, NewHttpValue("Content-Type", HTTP_CONTENT_TYPE));
+
+ // Creating a Data
+ str_size = sizeof(http_403_str) * 2 + StrLen(target) + StrLen(host);
+ str = Malloc(str_size);
+ StrCpy(str, str_size, http_403_str);
+
+ // TARGET
+ ReplaceUnsafeCharInTarget(target);
+ ReplaceStri(str, str_size, str, "$TARGET$", target);
+
+ // HOST
+ ReplaceStri(str, str_size, str, "$HOST$", host);
+
+ // PORT
+ ToStr(port_str, port);
+ ReplaceStri(str, str_size, str, "$PORT$", port_str);
+
+ // Transmission
+ ret = PostHttp(s, h, str, StrLen(str));
+
+ FreeHttpHeader(h);
+ Free(str);
+
+ return ret;
+}
+
+// Get the date and time string for the HTTP header
+void GetHttpDateStr(char *str, UINT size, UINT64 t)
+{
+ SYSTEMTIME s;
+ static char *wday[] =
+ {
+ "Sun", "Mon", "Tue", "Wed", "Thu", "Fri", "Sat",
+ };
+ static char *month[] =
+ {
+ "Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct",
+ "Nov", "Dec",
+ };
+ // Validate arguments
+ if (str == NULL)
+ {
+ return;
+ }
+ UINT64ToSystem(&s, t);
+
+ Format(str, size, "%s, %02u %s %04u %02u:%02u:%02u GMT",
+ wday[s.wDayOfWeek], s.wDay, month[s.wMonth - 1], s.wYear,
+ s.wHour, s.wMinute, s.wSecond);
+}
+
+// Get the Content-Length from the HTTP header
+UINT GetContentLength(HTTP_HEADER *header)
+{
+ UINT ret;
+ HTTP_VALUE *v;
+ // Validate arguments
+ if (header == NULL)
+ {
+ return 0;
+ }
+
+ v = GetHttpValue(header, "Content-Length");
+ if (v == NULL)
+ {
+ return 0;
+ }
+
+ ret = ToInt(v->Data);
+
+ return ret;
+}
+
+// Send the data in the HTTP
+bool PostHttp(SOCK *s, HTTP_HEADER *header, void *post_data, UINT post_size)
+{
+ char *header_str;
+ BUF *b;
+ bool ret;
+ // Validate arguments
+ if (s == NULL || header == NULL || (post_size != 0 && post_data == NULL))
+ {
+ return false;
+ }
+
+ // Check whether the Content-Lentgh exists?
+ if (GetHttpValue(header, "Content-Length") == NULL)
+ {
+ char tmp[MAX_SIZE];
+ // Add because it does not exist
+ ToStr(tmp, post_size);
+ AddHttpValue(header, NewHttpValue("Content-Length", tmp));
+ }
+
+ // Convert the header to string
+ header_str = HttpHeaderToStr(header);
+ if (header_str == NULL)
+ {
+ return false;
+ }
+ b = NewBuf();
+ WriteBuf(b, header_str, StrLen(header_str));
+ Free(header_str);
+
+ // Append the data
+ WriteBuf(b, post_data, post_size);
+
+ // Send
+ ret = SendAll(s, b->Buf, b->Size, s->SecureMode);
+
+ FreeBuf(b);
+
+ return ret;
+}
+
+// Convert a HTTP header to a string
+char *HttpHeaderToStr(HTTP_HEADER *header)
+{
+ BUF *b;
+ char *tmp;
+ UINT i;
+ char *s;
+ // Validate arguments
+ if (header == NULL)
+ {
+ return NULL;
+ }
+
+ tmp = Malloc(HTTP_HEADER_LINE_MAX_SIZE);
+ b = NewBuf();
+
+ // Header
+ Format(tmp, HTTP_HEADER_LINE_MAX_SIZE,
+ "%s %s %s\r\n", header->Method, header->Target, header->Version);
+ WriteBuf(b, tmp, StrLen(tmp));
+
+ // Value
+ for (i = 0;i < LIST_NUM(header->ValueList);i++)
+ {
+ HTTP_VALUE *v = (HTTP_VALUE *)LIST_DATA(header->ValueList, i);
+ Format(tmp, HTTP_HEADER_LINE_MAX_SIZE,
+ "%s: %s\r\n", v->Name, v->Data);
+ WriteBuf(b, tmp, StrLen(tmp));
+ }
+
+ // Trailing newline
+ WriteBuf(b, "\r\n", 2);
+ s = Malloc(b->Size + 1);
+ Copy(s, b->Buf, b->Size);
+ s[b->Size] = 0;
+
+ FreeBuf(b);
+ Free(tmp);
+
+ return s;
+}
+
+// Send the HTTP header
+bool SendHttpHeader(SOCK *s, HTTP_HEADER *header)
+{
+ char *str;
+ bool ret;
+ // Validate arguments
+ if (s == NULL || header == NULL)
+ {
+ return false;
+ }
+
+ // Convert to string
+ str = HttpHeaderToStr(header);
+
+ // Transmission
+ ret = SendAll(s, str, StrLen(str), s->SecureMode);
+
+ Free(str);
+
+ return ret;
+}
+
+// Receive an HTTP header
+HTTP_HEADER *RecvHttpHeader(SOCK *s)
+{
+ TOKEN_LIST *token = NULL;
+ char *str = NULL;
+ HTTP_HEADER *header = NULL;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return NULL;
+ }
+
+ // Get the first line
+ str = RecvLine(s, HTTP_HEADER_LINE_MAX_SIZE);
+ if (str == NULL)
+ {
+ goto LABEL_ERROR;
+ }
+
+ // Split into tokens
+ token = ParseToken(str, " ");
+ if (token->NumTokens < 3)
+ {
+ goto LABEL_ERROR;
+ }
+
+ Free(str);
+ str = NULL;
+
+ // Creating a header object
+ header = NewHttpHeader(token->Token[0], token->Token[1], token->Token[2]);
+
+ if (StrCmpi(header->Version, "HTTP/0.9") == 0)
+ {
+ // The header ends with this line
+ FreeToken(token);
+ return header;
+ }
+
+ // Get the subsequent lines
+ while (true)
+ {
+ UINT pos;
+ HTTP_VALUE *v;
+ char *value_name, *value_data;
+ str = RecvLine(s, HTTP_HEADER_LINE_MAX_SIZE);
+ if (str == NULL)
+ {
+ goto LABEL_ERROR;
+ }
+ Trim(str);
+
+ if (StrLen(str) == 0)
+ {
+ // End of header
+ Free(str);
+ str = NULL;
+ break;
+ }
+
+ // Get the position of the colon
+ pos = SearchStr(str, ":", 0);
+ if (pos == INFINITE)
+ {
+ // The colon does not exist
+ goto LABEL_ERROR;
+ }
+ if ((pos + 1) >= StrLen(str))
+ {
+ // There is no data
+ goto LABEL_ERROR;
+ }
+
+ // Divide into the name and the data
+ value_name = Malloc(pos + 1);
+ Copy(value_name, str, pos);
+ value_name[pos] = 0;
+ value_data = &str[pos + 1];
+
+ v = NewHttpValue(value_name, value_data);
+ if (v == NULL)
+ {
+ Free(value_name);
+ goto LABEL_ERROR;
+ }
+
+ Free(value_name);
+
+ AddHttpValue(header, v);
+ Free(str);
+ }
+
+ FreeToken(token);
+
+ return header;
+
+LABEL_ERROR:
+ // Memory release
+ if (token)
+ {
+ FreeToken(token);
+ }
+ if (str)
+ {
+ Free(str);
+ }
+ if (header)
+ {
+ FreeHttpHeader(header);
+ }
+ return NULL;
+}
+
+// Receive a line
+char *RecvLine(SOCK *s, UINT max_size)
+{
+ BUF *b;
+ char c;
+ char *str;
+ // Validate arguments
+ if (s == NULL || max_size == 0)
+ {
+ return NULL;
+ }
+
+ b = NewBuf();
+ while (true)
+ {
+ UCHAR *buf;
+ if (RecvAll(s, &c, sizeof(c), s->SecureMode) == false)
+ {
+ FreeBuf(b);
+ return NULL;
+ }
+ WriteBuf(b, &c, sizeof(c));
+ buf = (UCHAR *)b->Buf;
+ if (b->Size > max_size)
+ {
+ FreeBuf(b);
+ return NULL;
+ }
+ if (b->Size >= 1)
+ {
+ if (buf[b->Size - 1] == '\n')
+ {
+ b->Size--;
+ if (b->Size >= 1)
+ {
+ if (buf[b->Size - 1] == '\r')
+ {
+ b->Size--;
+ }
+ }
+ str = Malloc(b->Size + 1);
+ Copy(str, b->Buf, b->Size);
+ str[b->Size] = 0;
+ FreeBuf(b);
+
+ return str;
+ }
+ }
+ }
+}
+
+// Creating a new HTTP value
+HTTP_VALUE *NewHttpValue(char *name, char *data)
+{
+ HTTP_VALUE *v;
+ // Validate arguments
+ if (name == NULL || data == NULL)
+ {
+ return NULL;
+ }
+
+ v = ZeroMalloc(sizeof(HTTP_VALUE));
+
+ v->Name = CopyStr(name);
+ v->Data = CopyStr(data);
+
+ Trim(v->Name);
+ Trim(v->Data);
+
+ return v;
+}
+
+// Look for the HTTP value from the HTTP header
+HTTP_VALUE *GetHttpValue(HTTP_HEADER *header, char *name)
+{
+ HTTP_VALUE *v, t;
+ // Validate arguments
+ if (header == NULL || name == NULL)
+ {
+ return NULL;
+ }
+
+ t.Name = name;
+ v = Search(header->ValueList, &t);
+ if (v == NULL)
+ {
+ return NULL;
+ }
+
+ return v;
+}
+
+// Add a HTTP value to the HTTP header
+void AddHttpValue(HTTP_HEADER *header, HTTP_VALUE *value)
+{
+ // Validate arguments
+ if (header == NULL || value == NULL)
+ {
+ return;
+ }
+
+ if (LIST_NUM(header->ValueList) < HTTP_HEADER_MAX_LINES)
+ {
+ Insert(header->ValueList, value);
+ }
+ else
+ {
+ FreeHttpValue(value);
+ }
+}
+
+// Create an HTTP header
+HTTP_HEADER *NewHttpHeader(char *method, char *target, char *version)
+{
+ return NewHttpHeaderEx(method, target, version, false);
+}
+HTTP_HEADER *NewHttpHeaderEx(char *method, char *target, char *version, bool no_sort)
+{
+ HTTP_HEADER *header;
+ // Validate arguments
+ if (method == NULL || target == NULL || version == NULL)
+ {
+ return NULL;
+ }
+
+ header = ZeroMalloc(sizeof(HTTP_HEADER));
+
+ header->Method = CopyStr(method);
+ header->Target = CopyStr(target);
+ header->Version = CopyStr(version);
+ header->ValueList = NewListFast(no_sort ? NULL : CompareHttpValue);
+
+ return header;
+}
+
+// Comparison function of the HTTP value
+int CompareHttpValue(void *p1, void *p2)
+{
+ HTTP_VALUE *v1, *v2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ v1 = *(HTTP_VALUE **)p1;
+ v2 = *(HTTP_VALUE **)p2;
+ if (v1 == NULL || v2 == NULL)
+ {
+ return 0;
+ }
+ return StrCmpi(v1->Name, v2->Name);
+}
+
+// Release the HTTP value
+void FreeHttpValue(HTTP_VALUE *value)
+{
+ // Validate arguments
+ if (value == NULL)
+ {
+ return;
+ }
+
+ Free(value->Data);
+ Free(value->Name);
+
+ Free(value);
+}
+
+// Release the HTTP header
+void FreeHttpHeader(HTTP_HEADER *header)
+{
+ UINT i;
+ HTTP_VALUE **values;
+ // Validate arguments
+ if (header == NULL)
+ {
+ return;
+ }
+
+ Free(header->Method);
+ Free(header->Target);
+ Free(header->Version);
+
+ values = ToArray(header->ValueList);
+ for (i = 0;i < LIST_NUM(header->ValueList);i++)
+ {
+ FreeHttpValue(values[i]);
+ }
+ Free(values);
+
+ ReleaseList(header->ValueList);
+
+ Free(header);
+}
+
+// Receive a PACK
+PACK *RecvPack(SOCK *s)
+{
+ PACK *p;
+ BUF *b;
+ void *data;
+ UINT sz;
+ // Validate arguments
+ if (s == NULL || s->Type != SOCK_TCP)
+ {
+ return false;
+ }
+
+ if (RecvAll(s, &sz, sizeof(UINT), s->SecureMode) == false)
+ {
+ return false;
+ }
+ sz = Endian32(sz);
+ if (sz > MAX_PACK_SIZE)
+ {
+ return false;
+ }
+ data = MallocEx(sz, true);
+ if (RecvAll(s, data, sz, s->SecureMode) == false)
+ {
+ Free(data);
+ return false;
+ }
+
+ b = NewBuf();
+ WriteBuf(b, data, sz);
+ SeekBuf(b, 0, 0);
+ p = BufToPack(b);
+ FreeBuf(b);
+ Free(data);
+
+ return p;
+}
+
+// Receive a PACK (with checking the hash)
+PACK *RecvPackWithHash(SOCK *s)
+{
+ PACK *p;
+ BUF *b;
+ void *data;
+ UINT sz;
+ UCHAR hash1[SHA1_SIZE];
+ UCHAR hash2[SHA1_SIZE];
+ // Validate arguments
+ if (s == NULL || s->Type != SOCK_TCP)
+ {
+ return false;
+ }
+
+ if (RecvAll(s, &sz, sizeof(UINT), s->SecureMode) == false)
+ {
+ return false;
+ }
+ sz = Endian32(sz);
+ if (sz > MAX_PACK_SIZE)
+ {
+ return false;
+ }
+ data = MallocEx(sz, true);
+ if (RecvAll(s, data, sz, s->SecureMode) == false)
+ {
+ Free(data);
+ return false;
+ }
+
+ HashSha1(hash1, data, sz);
+ if (RecvAll(s, hash2, sizeof(hash2), s->SecureMode) == false)
+ {
+ Free(data);
+ return false;
+ }
+
+ if (Cmp(hash1, hash2, SHA1_SIZE) != 0)
+ {
+ Free(data);
+ return false;
+ }
+
+ b = NewBuf();
+ WriteBuf(b, data, sz);
+ SeekBuf(b, 0, 0);
+ p = BufToPack(b);
+ FreeBuf(b);
+ Free(data);
+
+ return p;
+}
+
+// Send a PACK
+bool SendPack(SOCK *s, PACK *p)
+{
+ BUF *b;
+ UINT sz;
+ // Validate arguments
+ if (s == NULL || p == NULL || s->Type != SOCK_TCP)
+ {
+ return false;
+ }
+
+ b = PackToBuf(p);
+ sz = Endian32(b->Size);
+
+ SendAdd(s, &sz, sizeof(UINT));
+ SendAdd(s, b->Buf, b->Size);
+ FreeBuf(b);
+
+ return SendNow(s, s->SecureMode);
+}
+
+// Send a Pack (with adding a hash)
+bool SendPackWithHash(SOCK *s, PACK *p)
+{
+ BUF *b;
+ UINT sz;
+ UCHAR hash[SHA1_SIZE];
+ // Validate arguments
+ if (s == NULL || p == NULL || s->Type != SOCK_TCP)
+ {
+ return false;
+ }
+
+ b = PackToBuf(p);
+ sz = Endian32(b->Size);
+
+ SendAdd(s, &sz, sizeof(UINT));
+ SendAdd(s, b->Buf, b->Size);
+ HashSha1(hash, b->Buf, b->Size);
+ SendAdd(s, hash, sizeof(hash));
+
+ FreeBuf(b);
+
+ return SendNow(s, s->SecureMode);
+}
+
+// Get SNI name from the data that has arrived to the TCP connection before accepting an SSL connection
+bool GetSniNameFromPreSslConnection(SOCK *s, char *sni, UINT sni_size)
+{
+ UCHAR tmp[1500];
+ UINT size;
+ // Validate arguments
+ if (s == NULL || sni == NULL)
+ {
+ return false;
+ }
+
+ size = Peek(s, tmp, sizeof(tmp));
+ if (size == 0)
+ {
+ return false;
+ }
+
+ return GetSniNameFromSslPacket(tmp, size, sni, sni_size);
+}
+
+// Get SNI name from the SSL packet
+bool GetSniNameFromSslPacket(UCHAR *packet_buf, UINT packet_size, char *sni, UINT sni_size)
+{
+ BUF *buf;
+ bool ret = false;
+ UCHAR content_type;
+ USHORT version;
+ USHORT handshake_length;
+
+ // Validate arguments
+ if (packet_buf == NULL || packet_size == 0)
+ {
+ return false;
+ }
+
+ 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))
+ {
+ version = Endian16(version);
+ handshake_length = Endian16(handshake_length);
+
+ if (version >= 0x0301)
+ {
+ UCHAR *handshake_data = Malloc(handshake_length);
+
+ if (ReadBuf(buf, handshake_data, handshake_length) == handshake_length)
+ {
+ BUF *buf2 = NewBufFromMemory(handshake_data, handshake_length);
+ USHORT handshake_type;
+ USHORT handshake_length_2;
+
+ if (ReadBuf(buf2, &handshake_type, 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);
+
+ if (handshake_type == 0x0100 && handshake_length_2 <= (handshake_length - 4))
+ {
+ USHORT version2;
+
+ if (ReadBuf(buf2, &version2, sizeof(USHORT)) == sizeof(USHORT))
+ {
+ version2 = Endian16(version2);
+
+ if (version2 >= 0x0301)
+ {
+ UCHAR rand[32];
+
+ if (ReadBuf(buf2, rand, sizeof(rand)) == sizeof(rand))
+ {
+ UCHAR session_id_len;
+
+ if (ReadBuf(buf2, &session_id_len, sizeof(UCHAR)) == sizeof(UCHAR))
+ {
+ if (ReadBuf(buf2, NULL, session_id_len) == session_id_len)
+ {
+ USHORT cipher_len;
+
+ if (ReadBuf(buf2, &cipher_len, sizeof(USHORT)) == sizeof(USHORT))
+ {
+ cipher_len = Endian16(cipher_len);
+
+ if (ReadBuf(buf2, NULL, cipher_len) == cipher_len)
+ {
+ UCHAR comps_len;
+
+ if (ReadBuf(buf2, &comps_len, sizeof(UCHAR)) == sizeof(UCHAR))
+ {
+ if (ReadBuf(buf2, NULL, comps_len) == comps_len)
+ {
+ USHORT ext_length;
+
+ if (ReadBuf(buf2, &ext_length, sizeof(USHORT)) == sizeof(USHORT))
+ {
+ UCHAR *ext_buf;
+
+ ext_length = Endian16(ext_length);
+
+ ext_buf = Malloc(ext_length);
+
+ if (ReadBuf(buf2, ext_buf, ext_length) == ext_length)
+ {
+ BUF *ebuf = NewBufFromMemory(ext_buf, ext_length);
+
+ while (ret == false)
+ {
+ USHORT type;
+ USHORT data_len;
+ UCHAR *data;
+
+ if (ReadBuf(ebuf, &type, sizeof(USHORT)) != sizeof(USHORT))
+ {
+ break;
+ }
+
+ if (ReadBuf(ebuf, &data_len, sizeof(USHORT)) != sizeof(USHORT))
+ {
+ break;
+ }
+
+ type = Endian16(type);
+ data_len = Endian16(data_len);
+
+ data = Malloc(data_len);
+
+ if (ReadBuf(ebuf, data, data_len) != data_len)
+ {
+ Free(data);
+ break;
+ }
+
+ if (type == 0x0000)
+ {
+ BUF *dbuf = NewBufFromMemory(data, data_len);
+
+ USHORT total_len;
+
+ if (ReadBuf(dbuf, &total_len, sizeof(USHORT)) == sizeof(USHORT))
+ {
+ UCHAR c;
+ total_len = Endian16(total_len);
+
+ if (ReadBuf(dbuf, &c, sizeof(UCHAR)) == sizeof(UCHAR))
+ {
+ if (c == 0)
+ {
+ USHORT name_len;
+
+ if (ReadBuf(dbuf, &name_len, sizeof(USHORT)) == sizeof(USHORT))
+ {
+ char *name_buf;
+ name_len = Endian16(name_len);
+
+ name_buf = ZeroMalloc(name_len + 1);
+
+ if (ReadBuf(dbuf, name_buf, name_len) == name_len)
+ {
+ ret = true;
+
+ StrCpy(sni, sni_size, name_buf);
+ }
+
+ Free(name_buf);
+ }
+ }
+ }
+ }
+
+ FreeBuf(dbuf);
+ }
+
+ Free(data);
+ }
+
+ FreeBuf(ebuf);
+ }
+
+ Free(ext_buf);
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ FreeBuf(buf2);
+ }
+
+ Free(handshake_data);
+ }
+ }
+
+ FreeBuf(buf);
+
+ if (ret)
+ {
+ Trim(sni);
+
+ if (IsEmptyStr(sni))
+ {
+ ret = false;
+ }
+ }
+
+ return ret;
+}
+
+// Developed by SoftEther VPN Project at University of Tsukuba in Japan.
+// Department of Computer Science has dozens of overly-enthusiastic geeks.
+// Join us: http://www.tsukuba.ac.jp/english/admission/
|