diff options
Diffstat (limited to 'src/Cedar/Connection.c')
-rw-r--r-- | src/Cedar/Connection.c | 3457 |
1 files changed, 3457 insertions, 0 deletions
diff --git a/src/Cedar/Connection.c b/src/Cedar/Connection.c new file mode 100644 index 00000000..5cc0296c --- /dev/null +++ b/src/Cedar/Connection.c @@ -0,0 +1,3457 @@ +// SoftEther VPN Source Code
+// Cedar Communication Module
+//
+// 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.
+
+
+// Connection.c
+// Connection Manager
+
+#include "CedarPch.h"
+
+// Determine whether the socket is to use to send
+#define IS_SEND_TCP_SOCK(ts) \
+ ((ts->Direction == TCP_BOTH) || ((ts->Direction == TCP_SERVER_TO_CLIENT) && (s->ServerMode)) || ((ts->Direction == TCP_CLIENT_TO_SERVER) && (s->ServerMode == false)))
+
+// Determine whether the socket is to use to receive
+#define IS_RECV_TCP_SOCK(ts) \
+ ((ts->Direction == TCP_BOTH) || ((ts->Direction == TCP_SERVER_TO_CLIENT) && (s->ServerMode == false)) || ((ts->Direction == TCP_CLIENT_TO_SERVER) && (s->ServerMode)))
+
+// Conversion of SECURE_SIGN
+void InRpcSecureSign(SECURE_SIGN *t, PACK *p)
+{
+ // Validate arguments
+ if (t == NULL || p == NULL)
+ {
+ return;
+ }
+
+ Zero(t, sizeof(SECURE_SIGN));
+ PackGetStr(p, "SecurePublicCertName", t->SecurePublicCertName, sizeof(t->SecurePublicCertName));
+ PackGetStr(p, "SecurePrivateKeyName", t->SecurePrivateKeyName, sizeof(t->SecurePrivateKeyName));
+ t->ClientCert = PackGetX(p, "ClientCert");
+ PackGetData2(p, "Random", t->Random, sizeof(t->Random));
+ PackGetData2(p, "Signature", t->Signature, sizeof(t->Signature));
+ t->UseSecureDeviceId = PackGetInt(p, "UseSecureDeviceId");
+ t->BitmapId = PackGetInt(p, "BitmapId");
+}
+void OutRpcSecureSign(PACK *p, SECURE_SIGN *t)
+{
+ // Validate arguments
+ if (p == NULL || t == NULL)
+ {
+ return;
+ }
+
+ PackAddStr(p, "SecurePublicCertName", t->SecurePublicCertName);
+ PackAddStr(p, "SecurePrivateKeyName", t->SecurePrivateKeyName);
+ PackAddX(p, "ClientCert", t->ClientCert);
+ PackAddData(p, "Random", t->Random, sizeof(t->Random));
+ PackAddData(p, "Signature", t->Signature, sizeof(t->Signature));
+ PackAddInt(p, "UseSecureDeviceId", t->UseSecureDeviceId);
+ PackAddInt(p, "BitmapId", t->BitmapId);
+}
+void FreeRpcSecureSign(SECURE_SIGN *t)
+{
+ // Validate arguments
+ if (t == NULL)
+ {
+ return;
+ }
+
+ FreeX(t->ClientCert);
+}
+
+// Generate the next packet
+BUF *NewKeepPacket(bool server_mode)
+{
+ BUF *b = NewBuf();
+ char *string = KEEP_ALIVE_STRING;
+
+ WriteBuf(b, string, StrLen(string));
+
+ SeekBuf(b, 0, 0);
+
+ return b;
+}
+
+// KEEP thread
+void KeepThread(THREAD *thread, void *param)
+{
+ KEEP *k = (KEEP *)param;
+ SOCK *s;
+ char server_name[MAX_HOST_NAME_LEN + 1];
+ UINT server_port;
+ bool udp_mode;
+ bool enabled;
+ // Validate arguments
+ if (thread == NULL || k == NULL)
+ {
+ return;
+ }
+
+WAIT_FOR_ENABLE:
+ Wait(k->HaltEvent, KEEP_POLLING_INTERVAL);
+
+ // Wait until it becomes enabled
+ while (true)
+ {
+ enabled = false;
+ Lock(k->lock);
+ {
+ if (k->Enable)
+ {
+ if (StrLen(k->ServerName) != 0 && k->ServerPort != 0 && k->Interval != 0)
+ {
+ StrCpy(server_name, sizeof(server_name), k->ServerName);
+ server_port = k->ServerPort;
+ udp_mode = k->UdpMode;
+ enabled = true;
+ }
+ }
+ }
+ Unlock(k->lock);
+ if (enabled)
+ {
+ break;
+ }
+ if (k->Halt)
+ {
+ return;
+ }
+ Wait(k->HaltEvent, KEEP_POLLING_INTERVAL);
+ }
+
+ if (udp_mode == false)
+ {
+ // TCP mode
+ // Try until a success to connection
+ while (true)
+ {
+ UINT64 connect_started_tick;
+ bool changed = false;
+ Lock(k->lock);
+ {
+ if (StrCmpi(k->ServerName, server_name) != 0 ||
+ k->ServerPort != server_port || k->Enable == false ||
+ k->UdpMode)
+ {
+ changed = true;
+ }
+ }
+ Unlock(k->lock);
+ if (changed)
+ {
+ // Settings are changed
+ goto WAIT_FOR_ENABLE;
+ }
+
+ if (k->Halt)
+ {
+ // Stop
+ return;
+ }
+
+ // Attempt to connect to the server
+ connect_started_tick = Tick64();
+ s = ConnectEx2(server_name, server_port, KEEP_TCP_TIMEOUT, (bool *)&k->Halt);
+ if (s != NULL)
+ {
+ // Successful connection
+ break;
+ }
+
+ // Connection failure: Wait until timeout or the setting is changed
+ while (true)
+ {
+ changed = false;
+ if (k->Halt)
+ {
+ // Stop
+ return;
+ }
+ Lock(k->lock);
+ {
+ if (StrCmpi(k->ServerName, server_name) != 0 ||
+ k->ServerPort != server_port || k->Enable == false ||
+ k->UdpMode)
+ {
+ changed = true;
+ }
+ }
+ Unlock(k->lock);
+
+ if (changed)
+ {
+ // Settings are changed
+ goto WAIT_FOR_ENABLE;
+ }
+
+ if ((Tick64() - connect_started_tick) >= KEEP_RETRY_INTERVAL)
+ {
+ break;
+ }
+
+ Wait(k->HaltEvent, KEEP_POLLING_INTERVAL);
+ }
+ }
+
+ // Success to connect the server
+ // Send and receive packet data periodically
+ if (s != NULL)
+ {
+ UINT64 last_packet_sent_time = 0;
+ while (true)
+ {
+ SOCKSET set;
+ UINT ret;
+ UCHAR buf[MAX_SIZE];
+ bool changed;
+
+ InitSockSet(&set);
+ AddSockSet(&set, s);
+
+ Select(&set, KEEP_POLLING_INTERVAL, k->Cancel, NULL);
+
+ ret = Recv(s, buf, sizeof(buf), false);
+ if (ret == 0)
+ {
+ // Disconnected
+ Disconnect(s);
+ ReleaseSock(s);
+ s = NULL;
+ }
+
+ if (s != NULL)
+ {
+ if ((Tick64() - last_packet_sent_time) >= (UINT64)k->Interval)
+ {
+ BUF *b;
+
+ // Send the next packet
+ last_packet_sent_time = Tick64();
+
+ b = NewKeepPacket(k->Server);
+
+ ret = Send(s, b->Buf, b->Size, false);
+ FreeBuf(b);
+
+ if (ret == 0)
+ {
+ // Disconnected
+ Disconnect(s);
+ ReleaseSock(s);
+ s = NULL;
+ }
+ }
+ }
+
+ changed = false;
+
+ Lock(k->lock);
+ {
+ if (StrCmpi(k->ServerName, server_name) != 0 ||
+ k->ServerPort != server_port || k->Enable == false ||
+ k->UdpMode)
+ {
+ changed = true;
+ }
+ }
+ Unlock(k->lock);
+
+ if (changed || s == NULL)
+ {
+ // Setting has been changed or disconnected
+ Disconnect(s);
+ ReleaseSock(s);
+ s = NULL;
+ goto WAIT_FOR_ENABLE;
+ }
+ else
+ {
+ if (k->Halt)
+ {
+ // Stop
+ Disconnect(s);
+ ReleaseSock(s);
+ return;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ IP dest_ip;
+ // UDP mode
+ // Try to create socket until it successes
+ while (true)
+ {
+ UINT64 connect_started_tick;
+ bool changed = false;
+ Lock(k->lock);
+ {
+ if (StrCmpi(k->ServerName, server_name) != 0 ||
+ k->ServerPort != server_port || k->Enable == false ||
+ k->UdpMode == false)
+ {
+ changed = true;
+ }
+ }
+ Unlock(k->lock);
+ if (changed)
+ {
+ // Settings are changed
+ goto WAIT_FOR_ENABLE;
+ }
+
+ if (k->Halt)
+ {
+ // Stop
+ return;
+ }
+
+ // Attempt to create a socket
+ connect_started_tick = Tick64();
+
+ // Attempt to resolve the name first
+ if (GetIP(&dest_ip, server_name))
+ {
+ // After successful name resolution, create a socket
+ s = NewUDP(0);
+ if (s != NULL)
+ {
+ // Creating success
+ break;
+ }
+ }
+
+ // Failure to create: wait until timeout or the setting is changed
+ while (true)
+ {
+ changed = false;
+ if (k->Halt)
+ {
+ // Stop
+ return;
+ }
+ Lock(k->lock);
+ {
+ if (StrCmpi(k->ServerName, server_name) != 0 ||
+ k->ServerPort != server_port || k->Enable == false ||
+ k->UdpMode)
+ {
+ changed = true;
+ }
+ }
+ Unlock(k->lock);
+
+ if (changed)
+ {
+ // Settings are changed
+ goto WAIT_FOR_ENABLE;
+ }
+
+ if ((Tick64() - connect_started_tick) >= KEEP_RETRY_INTERVAL)
+ {
+ break;
+ }
+
+ Wait(k->HaltEvent, KEEP_POLLING_INTERVAL);
+ }
+ }
+
+ // Send the packet data periodically
+ if (s != NULL)
+ {
+ UINT64 last_packet_sent_time = 0;
+ UINT num_ignore_errors = 0;
+ while (true)
+ {
+ SOCKSET set;
+ UINT ret;
+ UCHAR buf[MAX_SIZE];
+ bool changed;
+ IP src_ip;
+ UINT src_port;
+
+ InitSockSet(&set);
+ AddSockSet(&set, s);
+
+ Select(&set, KEEP_POLLING_INTERVAL, k->Cancel, NULL);
+
+ // Receive
+ ret = RecvFrom(s, &src_ip, &src_port, buf, sizeof(buf));
+ if (ret == 0)
+ {
+ if (s->IgnoreRecvErr == false)
+ {
+LABEL_DISCONNECTED:
+ // Disconnected
+ Disconnect(s);
+ ReleaseSock(s);
+ s = NULL;
+ }
+ else
+ {
+ if ((num_ignore_errors++) >= MAX_NUM_IGNORE_ERRORS)
+ {
+ goto LABEL_DISCONNECTED;
+ }
+ }
+ }
+
+ if (s != NULL)
+ {
+ if ((Tick64() - last_packet_sent_time) >= (UINT64)k->Interval)
+ {
+ BUF *b;
+
+ // Send the next packet
+ last_packet_sent_time = Tick64();
+
+ b = NewKeepPacket(k->Server);
+
+ ret = SendTo(s, &dest_ip, server_port, b->Buf, b->Size);
+ FreeBuf(b);
+
+ if (ret == 0 && s->IgnoreSendErr == false)
+ {
+ // Disconnected
+ Disconnect(s);
+ ReleaseSock(s);
+ s = NULL;
+ }
+ }
+ }
+
+ changed = false;
+
+ Lock(k->lock);
+ {
+ if (StrCmpi(k->ServerName, server_name) != 0 ||
+ k->ServerPort != server_port || k->Enable == false ||
+ k->UdpMode == false)
+ {
+ changed = true;
+ }
+ }
+ Unlock(k->lock);
+
+ if (changed || s == NULL)
+ {
+ // Setting has been changed or disconnected
+ Disconnect(s);
+ ReleaseSock(s);
+ s = NULL;
+ goto WAIT_FOR_ENABLE;
+ }
+ else
+ {
+ if (k->Halt)
+ {
+ // Stop
+ Disconnect(s);
+ ReleaseSock(s);
+ return;
+ }
+ }
+ }
+ }
+ }
+}
+
+// Stop the KEEP
+void StopKeep(KEEP *k)
+{
+ // Validate arguments
+ if (k == NULL)
+ {
+ return;
+ }
+
+ k->Halt = true;
+ Set(k->HaltEvent);
+ Cancel(k->Cancel);
+
+ WaitThread(k->Thread, INFINITE);
+ ReleaseThread(k->Thread);
+ DeleteLock(k->lock);
+
+ ReleaseCancel(k->Cancel);
+ ReleaseEvent(k->HaltEvent);
+
+ Free(k);
+}
+
+// Start the KEEP
+KEEP *StartKeep()
+{
+ KEEP *k = ZeroMalloc(sizeof(KEEP));
+
+ k->lock = NewLock();
+ k->HaltEvent = NewEvent();
+ k->Cancel = NewCancel();
+
+ // Thread start
+ k->Thread = NewThread(KeepThread, k);
+
+ return k;
+}
+
+// Copy the client authentication data
+CLIENT_AUTH *CopyClientAuth(CLIENT_AUTH *a)
+{
+ CLIENT_AUTH *ret;
+ // Validate arguments
+ if (a == NULL)
+ {
+ return NULL;
+ }
+
+ ret = ZeroMallocEx(sizeof(CLIENT_AUTH), true);
+
+ ret->AuthType = a->AuthType;
+ StrCpy(ret->Username, sizeof(ret->Username), a->Username);
+
+ switch (a->AuthType)
+ {
+ case CLIENT_AUTHTYPE_ANONYMOUS:
+ // Anonymous authentication
+ break;
+
+ case CLIENT_AUTHTYPE_PASSWORD:
+ // Password authentication
+ Copy(ret->HashedPassword, a->HashedPassword, SHA1_SIZE);
+ break;
+
+ case CLIENT_AUTHTYPE_PLAIN_PASSWORD:
+ // Plaintext password authentication
+ StrCpy(ret->PlainPassword, sizeof(ret->PlainPassword), a->PlainPassword);
+ break;
+
+ case CLIENT_AUTHTYPE_CERT:
+ // Certificate authentication
+ ret->ClientX = CloneX(a->ClientX);
+ ret->ClientK = CloneK(a->ClientK);
+ break;
+
+ case CLIENT_AUTHTYPE_SECURE:
+ // Secure device authentication
+ StrCpy(ret->SecurePublicCertName, sizeof(ret->SecurePublicCertName), a->SecurePublicCertName);
+ StrCpy(ret->SecurePrivateKeyName, sizeof(ret->SecurePrivateKeyName), a->SecurePrivateKeyName);
+ break;
+ }
+
+ return ret;
+}
+
+// Write data to the transmit FIFO (automatic encryption)
+void WriteSendFifo(SESSION *s, TCPSOCK *ts, void *data, UINT size)
+{
+ // Validate arguments
+ if (s == NULL || ts == NULL || data == NULL)
+ {
+ return;
+ }
+
+ if (s->UseFastRC4)
+ {
+ Encrypt(ts->SendKey, data, data, size);
+ }
+
+ WriteFifo(ts->SendFifo, data, size);
+}
+
+// Write data to the reception FIFO (automatic deccyption)
+void WriteRecvFifo(SESSION *s, TCPSOCK *ts, void *data, UINT size)
+{
+ // Validate arguments
+ if (s == NULL || ts == NULL || data == NULL)
+ {
+ return;
+ }
+
+ if (s->UseFastRC4)
+ {
+ Encrypt(ts->RecvKey, data, data, size);
+ }
+
+ WriteFifo(ts->RecvFifo, data, size);
+}
+
+// TCP socket receive
+UINT TcpSockRecv(SESSION *s, TCPSOCK *ts, void *data, UINT size)
+{
+ // Receive
+ return Recv(ts->Sock, data, size, s->UseSSLDataEncryption);
+}
+
+// TCP socket send
+UINT TcpSockSend(SESSION *s, TCPSOCK *ts, void *data, UINT size)
+{
+ // Transmission
+ return Send(ts->Sock, data, size, s->UseSSLDataEncryption);
+}
+
+// Send the data as UDP packet
+void SendDataWithUDP(SOCK *s, CONNECTION *c)
+{
+ UCHAR *buf;
+ BUF *b;
+ UINT64 dummy_64 = 0;
+ UCHAR dummy_buf[16];
+ UINT64 now = Tick64();
+ UINT ret;
+ bool force_flag = false;
+ bool packet_sent = false;
+ // Validate arguments
+ if (s == NULL || c == NULL)
+ {
+ return;
+ }
+
+ // Allocate the temporary buffer in heap
+ if (c->RecvBuf == NULL)
+ {
+ c->RecvBuf = Malloc(RECV_BUF_SIZE);
+ }
+ buf = c->RecvBuf;
+
+ if (c->Udp->NextKeepAliveTime == 0 || c->Udp->NextKeepAliveTime <= now)
+ {
+ force_flag = true;
+ }
+
+ // Creating a buffer
+ while ((c->SendBlocks->num_item > 0) || force_flag)
+ {
+ UINT *key32;
+ UINT64 *seq;
+ char *sign;
+
+ force_flag = false;
+
+ // Assemble a buffer from the current queue
+ b = NewBuf();
+
+ // Keep an area for packet header (16 bytes)
+ WriteBuf(b, dummy_buf, sizeof(dummy_buf));
+
+ // Pack the packets in transmission queue
+ LockQueue(c->SendBlocks);
+ {
+ while (true)
+ {
+ BLOCK *block;
+
+ if (b->Size > UDP_BUF_SIZE)
+ {
+ break;
+ }
+ block = GetNext(c->SendBlocks);
+ if (block == NULL)
+ {
+ break;
+ }
+
+ if (block->Size != 0)
+ {
+ WriteBufInt(b, block->Size);
+ WriteBuf(b, block->Buf, block->Size);
+
+ c->Session->TotalSendSize += (UINT64)block->SizeofData;
+ c->Session->TotalSendSizeReal += (UINT64)block->Size;
+ }
+
+ FreeBlock(block);
+ break;
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+
+ // Write sequence number and session key
+ sign = (char *)(((UCHAR *)b->Buf));
+ key32 = (UINT *)(((UCHAR *)b->Buf + 4));
+ seq = (UINT64 *)(((UCHAR *)b->Buf + 8));
+ Copy(sign, SE_UDP_SIGN, 4);
+ *key32 = Endian32(c->Session->SessionKey32);
+ *seq = Endian64(c->Udp->Seq++); // Increment the sequence number
+
+// InsertQueue(c->Udp->BufferQueue, b);
+
+ packet_sent = true;
+/* }
+
+ // Send a buffer
+ while (c->Udp->BufferQueue->num_item != 0)
+ {
+ FIFO *f = c->Udp->BufferQueue->fifo;
+ BUF **pb = (BUF**)(((UCHAR *)f->p) + f->pos);
+ BUF *b = *pb;
+
+*/ ret = SendTo(s, &c->Udp->ip, c->Udp->port, b->Buf, b->Size);
+ if (ret == SOCK_LATER)
+ {
+ // Blocking
+ Debug(".");
+// break;
+ }
+ if (ret != b->Size)
+ {
+ if (s->IgnoreSendErr == false)
+ {
+ // Error
+ Debug("******* SendTo Error !!!\n");
+ }
+ }
+
+ // Memory release
+ FreeBuf(b);
+// GetNext(c->Udp->BufferQueue);
+ }
+
+ if (packet_sent)
+ {
+ // KeepAlive time update
+ c->Udp->NextKeepAliveTime = now + (UINT64)GenNextKeepAliveSpan(c);
+ }
+}
+
+// Write the data of the UDP packet to the connection
+void PutUDPPacketData(CONNECTION *c, void *data, UINT size)
+{
+ BUF *b;
+ char sign[4];
+ // Validate arguments
+ if (c == NULL || data == NULL)
+ {
+ return;
+ }
+
+ // Examine the protocol
+ if (c->Protocol != CONNECTION_UDP)
+ {
+ // UDP protocol is not used
+ return;
+ }
+
+ // Buffer configuration
+ b = NewBuf();
+ WriteBuf(b, data, size);
+
+ SeekBuf(b, 0, 0);
+ ReadBuf(b, sign, 4);
+
+ // Signature confirmation
+ if (Cmp(sign, SE_UDP_SIGN, 4) == 0)
+ {
+ UINT key32;
+
+ // Session key number
+ key32 = ReadBufInt(b);
+
+ if (c->Session->SessionKey32 == key32)
+ {
+ UINT64 seq;
+
+ // Read the Sequence number
+ ReadBuf(b, &seq, sizeof(seq));
+ seq = Endian64(seq);
+
+ if ((UINT)(seq - c->Udp->RecvSeq - (UINT64)1))
+ {
+ //Debug("** UDP Seq Lost %u\n", (UINT)(seq - c->Udp->RecvSeq - (UINT64)1));
+ }
+ c->Udp->RecvSeq = seq;
+
+ //Debug("SEQ: %I32u\n", seq);
+
+ while (true)
+ {
+ UINT size;
+
+ size = ReadBufInt(b);
+ if (size == 0)
+ {
+ break;
+ }
+ else if (size <= MAX_PACKET_SIZE)
+ {
+ void *tmp;
+ BLOCK *block;
+
+ tmp = Malloc(size);
+ if (ReadBuf(b, tmp, size) != size)
+ {
+ Free(tmp);
+ break;
+ }
+
+ // Block configuration
+ block = NewBlock(tmp, size, 0);
+
+ // Insert Block
+ InsertReveicedBlockToQueue(c, block);
+ }
+ }
+
+ // Update the last communication time
+ c->Session->LastCommTime = Tick64();
+ }
+ else
+ {
+ Debug("Invalid SessionKey: 0x%X\n", key32);
+ }
+ }
+
+ FreeBuf(b);
+}
+
+// Add a block to the receive queue
+void InsertReveicedBlockToQueue(CONNECTION *c, BLOCK *block)
+{
+ SESSION *s;
+ // Validate arguments
+ if (c == NULL || block == NULL)
+ {
+ return;
+ }
+
+ s = c->Session;
+
+ if (c->Protocol == CONNECTION_TCP)
+ {
+ s->TotalRecvSizeReal += block->SizeofData;
+ s->TotalRecvSize += block->Size;
+ }
+
+ LockQueue(c->ReceivedBlocks);
+ {
+ InsertQueue(c->ReceivedBlocks, block);
+ }
+ UnlockQueue(c->ReceivedBlocks);
+}
+
+// Generate the interval to the next Keep-Alive packet
+// (This should be a random number for the network load reduction)
+UINT GenNextKeepAliveSpan(CONNECTION *c)
+{
+ UINT a, b;
+ // Validate arguments
+ if (c == NULL)
+ {
+ return INFINITE;
+ }
+
+ a = c->Session->Timeout;
+ b = rand() % (a / 2);
+ b = MAX(b, a / 5);
+
+ return b;
+}
+
+// send a Keep-Alive packet
+void SendKeepAlive(CONNECTION *c, TCPSOCK *ts)
+{
+ UINT size, i, num;
+ UINT size_be;
+ SESSION *s;
+ UCHAR *buf;
+ bool insert_natt_port = false;
+ // Validate arguments
+ if (c == NULL || ts == NULL)
+ {
+ return;
+ }
+
+ s = c->Session;
+
+ size = rand() % MAX_KEEPALIVE_SIZE;
+ num = KEEP_ALIVE_MAGIC;
+
+ if (s != NULL && s->UseUdpAcceleration && s->UdpAccel != NULL)
+ {
+ if (s->UdpAccel->MyPortByNatTServer != 0)
+ {
+ size = MAX(size, (StrLen(UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE) + sizeof(USHORT)));
+
+ insert_natt_port = true;
+ }
+ }
+
+ buf = MallocFast(size);
+
+ for (i = 0;i < size;i++)
+ {
+ buf[i] = rand();
+ }
+
+ if (insert_natt_port)
+ {
+ USHORT myport = Endian16((USHORT)s->UdpAccel->MyPortByNatTServer);
+
+ Copy(buf, UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE, StrLen(UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE));
+ Copy(buf + StrLen(UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE), &myport, sizeof(USHORT));
+ }
+
+ num = Endian32(num);
+ size_be = Endian32(size);
+ WriteSendFifo(c->Session, ts, &num, sizeof(UINT));
+ WriteSendFifo(c->Session, ts, &size_be, sizeof(UINT));
+ WriteSendFifo(c->Session, ts, buf, size);
+
+ c->Session->TotalSendSize += sizeof(UINT) * 2 + size;
+ c->Session->TotalSendSizeReal += sizeof(UINT) * 2 + size;
+
+ Free(buf);
+}
+
+// Transmission of block
+void ConnectionSend(CONNECTION *c)
+{
+ UINT i, num;
+ UINT64 now;
+ UINT min_count;
+ UINT64 max_recv_tick;
+ TCPSOCK **tcpsocks;
+ UINT size;
+ SESSION *s;
+ HUB *hub = NULL;
+ bool use_qos;
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ s = c->Session;
+ use_qos = s->QoS;
+
+ if (s != NULL)
+ {
+ hub = s->Hub;
+ }
+
+ now = Tick64();
+
+ // Protocol
+ if (c->Protocol == CONNECTION_TCP)
+ {
+ // TCP
+ TCP *tcp = c->Tcp;
+ TCPSOCK *ts;
+ TCPSOCK *ts_hp;
+ UINT num_available;
+ bool is_rudp = false;
+ LockList(tcp->TcpSockList);
+ {
+ num = LIST_NUM(tcp->TcpSockList);
+ tcpsocks = ToArrayEx(tcp->TcpSockList, true);
+ }
+ UnlockList(tcp->TcpSockList);
+
+ if (s != NULL)
+ {
+ is_rudp = s->IsRUDPSession;
+ }
+
+ // Select the socket that will be used to send
+ // Select a socket which have least delay count
+ min_count = INFINITE;
+ max_recv_tick = 0;
+ ts = NULL;
+ ts_hp = NULL;
+
+ num_available = 0;
+
+ if (c->IsInProc == false)
+ {
+ for (i = 0;i < num;i++)
+ {
+ TCPSOCK *tcpsock = tcpsocks[i];
+ if (tcpsock->Sock->Connected && tcpsock->Sock->AsyncMode &&
+ IS_SEND_TCP_SOCK(tcpsock))
+ {
+ // Processing of KeepAlive
+ if (now >= tcpsock->NextKeepAliveTime || tcpsock->NextKeepAliveTime == 0 ||
+ (s != NULL && s->UseUdpAcceleration && s->UdpAccel != NULL && s->UdpAccel->MyPortByNatTServerChanged))
+ {
+ // Send the KeepAlive
+ SendKeepAlive(c, tcpsock);
+ tcpsock->NextKeepAliveTime = now + (UINT64)GenNextKeepAliveSpan(c);
+
+ if (s->UseUdpAcceleration && s->UdpAccel != NULL)
+ {
+ s->UdpAccel->MyPortByNatTServerChanged = false;
+ }
+ }
+
+ // Count the number of available sockets to send
+ num_available++;
+
+ ts_hp = tcpsock;
+ }
+ }
+ }
+
+ for (i = 0;i < num;i++)
+ {
+ TCPSOCK *tcpsock = tcpsocks[i];
+ if (tcpsock->Sock->Connected && tcpsock->Sock->AsyncMode &&
+ IS_SEND_TCP_SOCK(tcpsock))
+ {
+ // Selection of the socket
+ bool b = false;
+
+ if (use_qos == false)
+ {
+ b = true;
+ }
+ else if (num_available < 2)
+ {
+ b = true;
+ }
+ else if (tcpsock != ts_hp)
+ {
+ b = true;
+ }
+
+ if (b)
+ {
+ if (is_rudp == false)
+ {
+ // Use a socket which have minimum delay occurrences in the case of such as a TCP socket
+ if (tcpsock->LateCount <= min_count)
+ {
+ min_count = tcpsock->LateCount;
+ ts = tcpsock;
+ }
+ }
+ else
+ {
+ // Use socket which have the largest last received time in the case of R-UDP socket
+ if (tcpsock->LastRecvTime >= max_recv_tick)
+ {
+ max_recv_tick = tcpsock->LastRecvTime;
+ ts = tcpsock;
+ }
+ }
+ }
+ }
+ }
+
+ if (ts_hp == NULL)
+ {
+ ts_hp = ts;
+ }
+
+ if (use_qos == false)
+ {
+ ts_hp = ts;
+ }
+
+ if (ts == NULL || ts_hp == NULL)
+ {
+ // The socket available to send doesn't currently exist
+ }
+ else
+ {
+ TCPSOCK *tss;
+ UINT j;
+ QUEUE *q;
+
+ if (s->UdpAccel != NULL)
+ {
+ UdpAccelSetTick(s->UdpAccel, now);
+ }
+
+ for (j = 0;j < 2;j++)
+ {
+ if (j == 0)
+ {
+ q = c->SendBlocks2;
+ tss = ts_hp;
+ }
+ else
+ {
+ q = c->SendBlocks;
+ tss = ts;
+ }
+ // I reserve the data to send on the selected socket ts
+ LockQueue(c->SendBlocks);
+ if (q->num_item != 0)
+ {
+ UINT num_data;
+ BLOCK *b;
+
+ if (tss->SendFifo->size >= MAX((MAX_SEND_SOCKET_QUEUE_SIZE / s->MaxConnection), MIN_SEND_SOCKET_QUEUE_SIZE))
+ {
+ // The size of the socket send queue is exceeded
+ // Unable to send
+ while (b = GetNext(q))
+ {
+ if (b != NULL)
+ {
+ c->CurrentSendQueueSize -= b->Size;
+ FreeBlock(b);
+ }
+ }
+ }
+ else
+ {
+ if (c->IsInProc == false)
+ {
+ if (s->UseUdpAcceleration && s->UdpAccel != NULL && UdpAccelIsSendReady(s->UdpAccel, true))
+ {
+ // UDP acceleration mode
+ while (b = GetNext(q))
+ {
+ UdpAccelSendBlock(s->UdpAccel, b);
+
+ s->TotalSendSize += b->Size;
+ s->TotalSendSizeReal += b->Size;
+
+ c->CurrentSendQueueSize -= b->Size;
+
+ FreeBlock(b);
+ }
+ }
+ else if (s->IsRUDPSession && s->EnableBulkOnRUDP && ts->Sock != NULL && ts->Sock->BulkSendTube != NULL)
+ {
+ // R-UDP bulk transfer
+ TUBE *t = ts->Sock->BulkSendTube;
+ bool flush = false;
+ TCP_PAIR_HEADER h;
+
+ Zero(&h, sizeof(h));
+ h.EnableHMac = s->EnableHMacOnBulkOfRUDP;
+
+ while (b = GetNext(q))
+ {
+ if (b->Compressed == false)
+ {
+ // Uncompressed
+ TubeSendEx(t, b->Buf, b->Size, &h, true);
+
+ s->TotalSendSize += b->Size;
+ s->TotalSendSizeReal += b->Size;
+
+ c->CurrentSendQueueSize -= b->Size;
+ }
+ else
+ {
+ // Compressed
+ UCHAR *new_buf = Malloc(b->Size + sizeof(UINT64));
+
+ WRITE_UINT64(new_buf, CONNECTION_BULK_COMPRESS_SIGNATURE);
+
+ Copy(new_buf + sizeof(UINT64), b->Buf, b->Size);
+
+ TubeSendEx(t, new_buf, b->Size + sizeof(UINT64), &h, true);
+
+ s->TotalSendSize += b->SizeofData;
+ s->TotalSendSizeReal += b->Size;
+
+ c->CurrentSendQueueSize -= b->Size;
+ }
+
+ FreeBlock(b);
+
+ flush = true;
+ }
+
+ if (flush)
+ {
+ TubeFlush(t);
+ }
+ }
+ else
+ {
+ // TCP/IP socket
+ bool update_keepalive_timer = false;
+ // Number of data
+ num_data = Endian32(q->num_item);
+ PROBE_DATA2("WriteSendFifo num", &num_data, sizeof(UINT));
+ WriteSendFifo(s, tss, &num_data, sizeof(UINT));
+
+ s->TotalSendSize += sizeof(UINT);
+ s->TotalSendSizeReal += sizeof(UINT);
+
+ while (b = GetNext(q))
+ {
+ // Size data
+ UINT size_data;
+ size_data = Endian32(b->Size);
+ PROBE_DATA2("WriteSendFifo size", &size_data, sizeof(UINT));
+ WriteSendFifo(s, tss, &size_data, sizeof(UINT));
+
+ c->CurrentSendQueueSize -= b->Size;
+
+ s->TotalSendSize += sizeof(UINT);
+ s->TotalSendSizeReal += sizeof(UINT);
+
+ // Data body
+ PROBE_DATA2("WriteSendFifo data", b->Buf, b->Size);
+ WriteSendFifo(s, tss, b->Buf, b->Size);
+
+ s->TotalSendSize += b->SizeofData;
+ s->TotalSendSizeReal += b->Size;
+
+ update_keepalive_timer = true;
+
+ // Block release
+ FreeBlock(b);
+ }
+
+ if (s->UseUdpAcceleration && s->UdpAccel != NULL && UdpAccelIsSendReady(s->UdpAccel, false))
+ {
+ update_keepalive_timer = false;
+ }
+
+ if (update_keepalive_timer)
+ {
+ // Increase the KeepAlive timer
+ tss->NextKeepAliveTime = now + (UINT64)GenNextKeepAliveSpan(c);
+ }
+ }
+ }
+ else
+ {
+ bool flush = false;
+ // In-process socket
+ while (b = GetNext(q))
+ {
+ TubeSendEx(ts->Sock->SendTube, b->Buf, b->Size, NULL, true);
+ flush = true;
+
+ s->TotalSendSize += b->Size;
+ s->TotalSendSizeReal += b->Size;
+
+ c->CurrentSendQueueSize -= b->Size;
+
+ FreeBlock(b);
+ }
+
+ if (flush)
+ {
+ TubeFlush(ts->Sock->SendTube);
+ }
+ }
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+ }
+ }
+
+ // Send the reserved data to send registered in each socket now
+ if (c->IsInProc == false)
+ {
+ for (i = 0;i < num;i++)
+ {
+ ts = tcpsocks[i];
+
+SEND_START:
+ if (ts->Sock->Connected == false)
+ {
+ s->LastTryAddConnectTime = Tick64();
+ // Communication is disconnected
+ LockList(tcp->TcpSockList);
+ {
+ // Remove the socket from socket list
+ Delete(tcp->TcpSockList, ts);
+ // Release of TCPSOCK
+ FreeTcpSock(ts);
+ // Decrement the count
+ Dec(c->CurrentNumConnection);
+ Debug("--- TCP Connection Decremented: %u (%s Line %u)\n", Count(c->CurrentNumConnection), __FILE__, __LINE__);
+ Debug("LIST_NUM(tcp->TcpSockList): %u\n", LIST_NUM(tcp->TcpSockList));
+ }
+ UnlockList(tcp->TcpSockList);
+
+ continue;
+ }
+
+ // Get Fifo size
+ if (ts->SendFifo->size != 0)
+ {
+ UCHAR *buf;
+ UINT want_send_size;
+ // Send only if the data to send exists by 1 byte or more
+ // Get the pointer to the buffer
+ buf = (UCHAR *)ts->SendFifo->p + ts->SendFifo->pos;
+ want_send_size = ts->SendFifo->size;
+
+ PROBE_DATA2("TcpSockSend", buf, want_send_size);
+ size = TcpSockSend(s, ts, buf, want_send_size);
+
+ if (size == 0)
+ {
+ // Disconnected
+ continue;
+ }
+ else if (size == SOCK_LATER)
+ {
+ // Packet is jammed
+ ts->LateCount++; // Increment of the delay counter
+ PROBE_STR("ts->LateCount++;");
+ }
+ else
+ {
+ // Packet is sent only by 'size'
+ // Advance FIFO
+ ReadFifo(ts->SendFifo, NULL, size);
+ if (size < want_send_size)
+ {
+ // Fail to transmit all of the data that has been scheduled
+#ifdef USE_PROBE
+ {
+ char tmp[MAX_SIZE];
+
+ snprintf(tmp, sizeof(tmp), "size < want_send_size: %u < %u",
+ size, want_send_size);
+
+ PROBE_STR(tmp);
+ }
+#endif // USE_PROBE
+ }
+ else
+ {
+ // Because sending all the packets is completed
+ // (The queue is exhausted), reset the delay counter
+ ts->LateCount = 0;
+
+ PROBE_STR("TcpSockSend All Completed");
+ }
+ // Updated the last communication date and time
+ c->Session->LastCommTime = now;
+
+ goto SEND_START;
+ }
+ }
+ }
+ }
+
+ Free(tcpsocks);
+ }
+ else if (c->Protocol == CONNECTION_UDP)
+ {
+ // UDP
+ UDP *udp = c->Udp;
+ SOCK *sock = NULL;
+
+ Lock(c->lock);
+ {
+ sock = udp->s;
+ if (sock != NULL)
+ {
+ AddRef(sock->ref);
+ }
+ }
+ Unlock(c->lock);
+
+ if (sock != NULL)
+ {
+ // Send with UDP
+
+ // KeepAlive sending
+ if ((udp->NextKeepAliveTime == 0 || udp->NextKeepAliveTime <= now) ||
+ (c->SendBlocks->num_item != 0) || (udp->BufferQueue->num_item != 0))
+ {
+ // Send the current queue with UDP
+ SendDataWithUDP(sock, c);
+ }
+ }
+
+ if (sock != NULL)
+ {
+ ReleaseSock(sock);
+ }
+ }
+ else if (c->Protocol == CONNECTION_HUB_SECURE_NAT)
+ {
+ // SecureNAT session
+ SNAT *snat = s->SecureNAT;
+ VH *v = snat->Nat->Virtual;
+
+ LockQueue(c->SendBlocks);
+ {
+ BLOCK *block;
+ UINT num_packet = 0;
+
+ if (hub != NULL)
+ {
+ NatSetHubOption(v, hub->Option);
+ }
+
+ while (block = GetNext(c->SendBlocks))
+ {
+ num_packet++;
+ c->CurrentSendQueueSize -= block->Size;
+ VirtualPutPacket(v, block->Buf, block->Size);
+ Free(block);
+ }
+
+ if (num_packet != 0)
+ {
+ VirtualPutPacket(v, NULL, 0);
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+ }
+ else if (c->Protocol == CONNECTION_HUB_LAYER3)
+ {
+ // Layer-3 session
+ L3IF *f = s->L3If;
+
+ LockQueue(c->SendBlocks);
+ {
+ BLOCK *block;
+ UINT num_packet = 0;
+
+ while (block = GetNext(c->SendBlocks))
+ {
+ num_packet++;
+ c->CurrentSendQueueSize -= block->Size;
+ L3PutPacket(f, block->Buf, block->Size);
+ Free(block);
+ }
+
+ if (num_packet != 0)
+ {
+ L3PutPacket(f, NULL, 0);
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+ }
+ else if (c->Protocol == CONNECTION_HUB_LINK_SERVER)
+ {
+ // HUB Link
+ LINK *k = (LINK *)s->Link;
+
+ if (k != NULL)
+ {
+ LockQueue(c->SendBlocks);
+ {
+ UINT num_blocks = 0;
+ LockQueue(k->SendPacketQueue);
+ {
+ BLOCK *block;
+
+ // Transfer the packet queue to the client thread
+ while (block = GetNext(c->SendBlocks))
+ {
+ num_blocks++;
+ c->CurrentSendQueueSize -= block->Size;
+ InsertQueue(k->SendPacketQueue, block);
+ }
+ }
+ UnlockQueue(k->SendPacketQueue);
+
+ if (num_blocks != 0)
+ {
+ // Issue of cancellation
+ Cancel(k->ClientSession->Cancel1);
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+ }
+ }
+ else if (c->Protocol == CONNECTION_HUB_BRIDGE)
+ {
+ // Local bridge
+ BRIDGE *b = s->Bridge;
+
+ if (b != NULL)
+ {
+ if (b->Active)
+ {
+ LockQueue(c->SendBlocks);
+ {
+ BLOCK *block;
+ UINT num_packet = c->SendBlocks->num_item; // Packet count
+
+ if (num_packet != 0)
+ {
+ // Packet data array
+ void **datas = MallocFast(sizeof(void *) * num_packet);
+ UINT *sizes = MallocFast(sizeof(UINT *) * num_packet);
+ UINT i;
+
+ i = 0;
+ while (block = GetNext(c->SendBlocks))
+ {
+ if (hub != NULL && hub->Option != NULL && hub->Option->DisableUdpFilterForLocalBridgeNic == false &&
+ b->Eth != NULL && IsDhcpPacketForSpecificMac(block->Buf, block->Size, b->Eth->MacAddress))
+ {
+ // DHCP Packet is filtered
+ datas[i] = NULL;
+ sizes[i] = 0;
+
+ Free(block->Buf);
+ }
+ else
+ {
+ datas[i] = block->Buf;
+ sizes[i] = block->Size;
+
+ if (block->Size > 1514)
+ {
+ NormalizeEthMtu(b, c, block->Size);
+ }
+ }
+
+ c->CurrentSendQueueSize -= block->Size;
+ Free(block);
+ i++;
+ }
+
+ // Write the packet
+ EthPutPackets(b->Eth, num_packet, datas, sizes);
+
+ Free(datas);
+ Free(sizes);
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+ }
+ }
+ }
+}
+
+// Reception of the block
+void ConnectionReceive(CONNECTION *c, CANCEL *c1, CANCEL *c2)
+{
+ UINT i, num;
+ SOCKSET set;
+ SESSION *s;
+ TCPSOCK **tcpsocks;
+ UCHAR *buf;
+ UINT size;
+ UINT64 now;
+ UINT time;
+ UINT num_delayed = 0;
+ bool no_spinlock_for_delay = false;
+ HUB *hub = NULL;
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ PROBE_STR("ConnectionReceive");
+
+ s = c->Session;
+
+ if (s != NULL)
+ {
+ hub = s->Hub;
+ }
+
+ if (hub != NULL)
+ {
+ no_spinlock_for_delay = hub->Option->NoSpinLockForPacketDelay;
+ }
+
+ now = Tick64();
+
+ if (c->RecvBuf == NULL)
+ {
+ c->RecvBuf = Malloc(RECV_BUF_SIZE);
+ }
+ buf = c->RecvBuf;
+
+ // Protocol
+ if (c->Protocol == CONNECTION_TCP)
+ {
+ // TCP
+ TCP *tcp = c->Tcp;
+ UINT next_delay_packet_diff = 0;
+
+ // Disconnect if disconnection interval is specified
+ if (s->ServerMode == false)
+ {
+ if (s->ClientOption->ConnectionDisconnectSpan != 0)
+ {
+ LockList(tcp->TcpSockList);
+ {
+ UINT i;
+ for (i = 0;i < LIST_NUM(tcp->TcpSockList);i++)
+ {
+ TCPSOCK *ts = LIST_DATA(tcp->TcpSockList, i);
+ if (ts->DisconnectTick != 0 &&
+ ts->DisconnectTick <= now)
+ {
+ Debug("ts->DisconnectTick <= now\n");
+ Disconnect(ts->Sock);
+ }
+ }
+ }
+ UnlockList(tcp->TcpSockList);
+ }
+ }
+
+ if (s->HalfConnection && (s->ServerMode == false))
+ {
+ // Check the direction of the current TCP connections.
+ // Disconnect one if the number of connections reaches
+ // the limit and has only one direction
+ LockList(tcp->TcpSockList);
+ {
+ UINT i, num;
+ UINT c2s, s2c;
+ c2s = s2c = 0;
+ num = LIST_NUM(tcp->TcpSockList);
+ if (num >= s->MaxConnection)
+ {
+ TCPSOCK *ts;
+ for (i = 0;i < num;i++)
+ {
+ ts = LIST_DATA(tcp->TcpSockList, i);
+ if (ts->Direction == TCP_SERVER_TO_CLIENT)
+ {
+ s2c++;
+ }
+ else
+ {
+ c2s++;
+ }
+ }
+ if (s2c == 0 || c2s == 0)
+ {
+ // Disconnect the last socket
+ Disconnect(ts->Sock);
+ Debug("Disconnect (s2c=%u, c2s=%u)\n", s2c, c2s);
+ }
+ }
+ }
+ UnlockList(tcp->TcpSockList);
+ }
+
+ // Initializing the socket set
+ InitSockSet(&set);
+ LockList(tcp->TcpSockList);
+ {
+ num = LIST_NUM(tcp->TcpSockList);
+ tcpsocks = ToArrayEx(tcp->TcpSockList, true);
+ }
+ UnlockList(tcp->TcpSockList);
+
+ for (i = 0;i < num;i++)
+ {
+ AddSockSet(&set, tcpsocks[i]->Sock);
+ }
+
+ if (s->UseUdpAcceleration && s->UdpAccel != NULL)
+ {
+ if (s->UdpAccel->UdpSock != NULL)
+ {
+ AddSockSet(&set, s->UdpAccel->UdpSock);
+ }
+ }
+
+ // Select
+ time = SELECT_TIME;
+ if (s->VirtualHost)
+ {
+ time = MIN(time, SELECT_TIME_FOR_NAT);
+ }
+ next_delay_packet_diff = GetNextDelayedPacketTickDiff(s);
+ time = MIN(time, next_delay_packet_diff);
+ num_delayed = LIST_NUM(s->DelayedPacketList);
+
+ PROBE_STR("ConnectionReceive: Select 0");
+
+ if (s->Flag1 != set.NumSocket)
+ {
+ Select(&set, (num_delayed == 0 ? time : 1), c1, c2);
+ s->Flag1 = set.NumSocket;
+ }
+ else
+ {
+ if (no_spinlock_for_delay || time >= 50 || num_delayed == false)
+ {
+ Select(&set, (num_delayed == 0 ? time : (time > 100 ? (time - 100) : 1)), c1, c2);
+ s->Flag1 = set.NumSocket;
+ }
+ else
+ {
+ YieldCpu();
+ }
+ }
+
+ PROBE_STR("ConnectionReceive: Select 1");
+
+ if (s->UseUdpAcceleration && s->UdpAccel != NULL)
+ {
+ // Read the data received by the UDP If using the UDP acceleration mode
+ UdpAccelSetTick(s->UdpAccel, now);
+ UdpAccelPoll(s->UdpAccel);
+
+ if (s->UdpAccelMss == 0)
+ {
+ s->UdpAccelMss = UdpAccelCalcMss(s->UdpAccel);
+ }
+
+ while (true)
+ {
+ BLOCK *b = GetNext(s->UdpAccel->RecvBlockQueue);
+
+ if (b == NULL)
+ {
+ break;
+ }
+
+ if (b->Size > MAX_PACKET_SIZE)
+ {
+ // Packet size exceeded
+ FreeBlock(b);
+ }
+ else
+ {
+ // Add the data block to queue
+ InsertReveicedBlockToQueue(c, b);
+ }
+ }
+ }
+
+ {
+ bool new_status = UdpAccelIsSendReady(s->UdpAccel, true);
+
+ if (s->IsUsingUdpAcceleration != new_status)
+ {
+ Debug("UDP Status Changed: %u\n", new_status);
+ }
+
+ s->IsUsingUdpAcceleration = new_status;
+ }
+
+ // Read all the data that has arrived to the TCP socket
+ for (i = 0;i < num;i++)
+ {
+ TCPSOCK *ts = tcpsocks[i];
+ SOCK *sock = ts->Sock;
+
+ if (s->IsRUDPSession)
+ {
+ TUBE *t = sock->BulkRecvTube;
+
+ if (s->EnableBulkOnRUDP)
+ {
+ // R-UDP bulk transfer data reception
+ if (t != NULL && IsTubeConnected(t))
+ {
+ while (true)
+ {
+ TUBEDATA *d = TubeRecvAsync(t);
+ BLOCK *block;
+ if (d == NULL)
+ {
+ // All reception complete
+ break;
+ }
+
+ if (d->DataSize > sizeof(UINT64) && READ_UINT64(d->Data) == CONNECTION_BULK_COMPRESS_SIGNATURE)
+ {
+ // Compression
+ block = NewBlock(Clone(((UCHAR *)d->Data) + sizeof(UINT64),
+ d->DataSize - sizeof(UINT64)),
+ d->DataSize - sizeof(UINT64),
+ -1);
+ }
+ else
+ {
+ // Uncompressed
+ block = NewBlock(Clone(d->Data, d->DataSize), d->DataSize, 0);
+ }
+
+ if (block->Size > MAX_PACKET_SIZE)
+ {
+ // Packet size exceeded
+ FreeBlock(block);
+ }
+ else
+ {
+ // Add the data block to queue
+ InsertReveicedBlockToQueue(c, block);
+ }
+
+ FreeTubeData(d);
+
+ ts->LastCommTime = now;
+ ts->LastRecvTime = now;
+ c->Session->LastCommTime = now;
+ }
+ }
+ }
+ }
+
+ if (c->IsInProc)
+ {
+ TUBEDATA *d;
+ // Socket for in-process connection
+ if (IsTubeConnected(sock->RecvTube) == false)
+ {
+ // Communication is disconnected
+ goto DISCONNECT_THIS_TCP;
+ }
+
+ while (true)
+ {
+ BLOCK *block;
+ // Get the packet data from the tube
+ d = TubeRecvAsync(sock->RecvTube);
+ if (d == NULL)
+ {
+ // All acquisition completed
+ break;
+ }
+
+ block = NewBlock(Clone(d->Data, d->DataSize), d->DataSize, 0);
+
+ if (block->Size > MAX_PACKET_SIZE)
+ {
+ // Packet size exceeded
+ FreeBlock(block);
+ }
+ else
+ {
+ // Add the data block to queue
+ InsertReveicedBlockToQueue(c, block);
+ }
+
+ FreeTubeData(d);
+ }
+
+ c->Session->LastCommTime = now;
+ }
+ else
+ {
+ // A normal socket (Not in-process)
+ if (ts->WantSize == 0)
+ {
+ // Read for sizeof(UINT) first
+ ts->WantSize = sizeof(UINT);
+ }
+
+RECV_START:
+ // Receive
+ size = TcpSockRecv(s, ts, buf, RECV_BUF_SIZE);
+/*
+ // Experiment
+ if (c->ServerMode)
+ {
+ if ((ts->EstablishedTick + (UINT64)3000) <= now)
+ {
+ size = 0;
+ WHERE;
+ }
+ }*/
+
+ if (size == 0)
+ {
+DISCONNECT_THIS_TCP:
+ s->LastTryAddConnectTime = Tick64();
+ s->NumDisconnected++;
+ // Communication is disconnected
+ LockList(tcp->TcpSockList);
+ {
+ // Remove the socket from socket list
+ Delete(tcp->TcpSockList, ts);
+ // Release of TCPSOCK
+ FreeTcpSock(ts);
+ // Decrement
+ Dec(c->CurrentNumConnection);
+ Debug("--- TCP Connection Decremented: %u (%s Line %u)\n", Count(c->CurrentNumConnection), __FILE__, __LINE__);
+ Debug("LIST_NUM(tcp->TcpSockList): %u\n", LIST_NUM(tcp->TcpSockList));
+ }
+ UnlockList(tcp->TcpSockList);
+
+ continue;
+ }
+ else if (size == SOCK_LATER)
+ {
+ // State of waiting reception : don't do anything
+ if (IS_RECV_TCP_SOCK(ts))
+ {
+ if ((now > ts->LastCommTime) && ((now - ts->LastCommTime) >= ((UINT64)s->Timeout)))
+ {
+ // The connection has timed out
+ Debug("Connection %u Timeouted.\n", i);
+ goto DISCONNECT_THIS_TCP;
+ }
+ }
+ }
+ else
+ {
+ // Update the last communication time
+ ts->LastCommTime = now;
+ c->Session->LastCommTime = now;
+ ts->LastRecvTime = now;
+
+ // Write the received data into the FIFO
+ PROBE_DATA2("WriteRecvFifo", buf, size);
+ WriteRecvFifo(s, ts, buf, size);
+
+ // Stop receiving when the receive buffer is full
+ if (ts->RecvFifo->size < MAX_SEND_SOCKET_QUEUE_SIZE)
+ {
+ goto RECV_START;
+ }
+ }
+
+ // process the data written to FIFO
+ while (ts->RecvFifo->size >= ts->WantSize)
+ {
+ UCHAR *buf;
+ void *data;
+ BLOCK *block;
+ UINT sz;
+ // A sufficient amount of data is already stored
+ // Get the pointer of the data
+ buf = (UCHAR *)ts->RecvFifo->p + ts->RecvFifo->pos;
+
+ switch (ts->Mode)
+ {
+ case 0:
+ // The number of Data blocks
+ ts->WantSize = sizeof(UINT);
+ Copy(&sz, buf, sizeof(UINT));
+ PROBE_DATA2("ReadFifo 0", buf, sizeof(UINT));
+ sz = Endian32(sz);
+ ts->NextBlockNum = sz;
+ ReadFifo(ts->RecvFifo, NULL, sizeof(UINT));
+
+ s->TotalRecvSize += sizeof(UINT);
+ s->TotalRecvSizeReal += sizeof(UINT);
+
+ ts->CurrentPacketNum = 0;
+ if (ts->NextBlockNum != 0)
+ {
+ if (ts->NextBlockNum == KEEP_ALIVE_MAGIC)
+ {
+ ts->Mode = 3;
+ }
+ else
+ {
+ ts->Mode = 1;
+ }
+ }
+ break;
+
+ case 1:
+ // Data block size
+ Copy(&sz, buf, sizeof(UINT));
+ sz = Endian32(sz);
+ PROBE_DATA2("ReadFifo 1", buf, sizeof(UINT));
+ if (sz > (MAX_PACKET_SIZE * 2))
+ {
+ // received a strange data size
+ // TCP/IP Error?
+ Debug("%s %u sz > (MAX_PACKET_SIZE * 2)\n", __FILE__, __LINE__);
+ Disconnect(ts->Sock);
+ }
+ ts->NextBlockSize = MIN(sz, MAX_PACKET_SIZE * 2);
+ ReadFifo(ts->RecvFifo, NULL, sizeof(UINT));
+
+ s->TotalRecvSize += sizeof(UINT);
+ s->TotalRecvSizeReal += sizeof(UINT);
+
+ ts->WantSize = ts->NextBlockSize;
+ if (ts->WantSize != 0)
+ {
+ ts->Mode = 2;
+ }
+ else
+ {
+ ts->Mode = 1;
+ ts->WantSize = sizeof(UINT);
+ ts->CurrentPacketNum++;
+ if (ts->CurrentPacketNum >= ts->NextBlockNum)
+ {
+ ts->Mode = 0;
+ }
+ }
+ break;
+
+ case 2:
+ // Data block body
+ ts->WantSize = sizeof(UINT);
+ ts->CurrentPacketNum++;
+ data = MallocFast(ts->NextBlockSize);
+ Copy(data, buf, ts->NextBlockSize);
+ PROBE_DATA2("ReadFifo 2", buf, ts->NextBlockSize);
+ ReadFifo(ts->RecvFifo, NULL, ts->NextBlockSize);
+ block = NewBlock(data, ts->NextBlockSize, s->UseCompress ? -1 : 0);
+
+ if (block->Size > MAX_PACKET_SIZE)
+ {
+ // Packet size exceeded
+ FreeBlock(block);
+ }
+ else
+ {
+ // Add the data block to queue
+ InsertReveicedBlockToQueue(c, block);
+ }
+
+ if (ts->CurrentPacketNum >= ts->NextBlockNum)
+ {
+ // Reception of all the data blocks completed
+ ts->Mode = 0;
+ }
+ else
+ {
+ // Receive next data block size
+ ts->Mode = 1;
+ }
+ break;
+
+ case 3:
+ // Keep-Alive packet size
+ ts->Mode = 4;
+ Copy(&sz, buf, sizeof(UINT));
+ PROBE_DATA2("ReadFifo 3", buf, sizeof(UINT));
+ sz = Endian32(sz);
+ if (sz > MAX_KEEPALIVE_SIZE)
+ {
+ // received a strange data size
+ // TCP/IP Error?
+ Debug("%s %u sz > MAX_KEEPALIVE_SIZE\n", __FILE__, __LINE__);
+ Disconnect(ts->Sock);
+ }
+ ts->NextBlockSize = MIN(sz, MAX_KEEPALIVE_SIZE);
+ ReadFifo(ts->RecvFifo, NULL, sizeof(UINT));
+
+ s->TotalRecvSize += sizeof(UINT);
+ s->TotalRecvSizeReal += sizeof(UINT);
+
+ ts->WantSize = sz;
+ break;
+
+ case 4:
+ // Keep-Alive packet body
+ //Debug("KeepAlive Recved.\n");
+ ts->Mode = 0;
+ sz = ts->NextBlockSize;
+
+ if (sz >= (StrLen(UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE) + sizeof(USHORT)))
+ {
+ UCHAR *keep_alive_buffer = FifoPtr(ts->RecvFifo);
+
+ if (Cmp(keep_alive_buffer, UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE, StrLen(UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE)) == 0)
+ {
+ USHORT us = READ_USHORT(keep_alive_buffer + StrLen(UDP_NAT_T_PORT_SIGNATURE_IN_KEEP_ALIVE));
+
+ if (us != 0)
+ {
+ if (s->UseUdpAcceleration && s->UdpAccel != NULL)
+ {
+ UINT port = (UINT)us;
+
+ if (s->UdpAccel->YourPortByNatTServer != port)
+ {
+ s->UdpAccel->YourPortByNatTServer = port;
+ s->UdpAccel->YourPortByNatTServerChanged = true;
+
+ Debug("s->UdpAccel->YourPortByNatTServer: %u\n",
+ s->UdpAccel->YourPortByNatTServer);
+ }
+ }
+ }
+ }
+ }
+
+ PROBE_DATA2("ReadFifo 4", NULL, 0);
+ ReadFifo(ts->RecvFifo, NULL, sz);
+
+ s->TotalRecvSize += sz;
+ s->TotalRecvSizeReal += sz;
+
+ ts->WantSize = sizeof(UINT);
+ break;
+ }
+ }
+ }
+ }
+
+ Free(tcpsocks);
+ }
+ else if (c->Protocol == CONNECTION_UDP)
+ {
+ // UDP
+ UDP *udp = c->Udp;
+ SOCK *sock = NULL;
+
+ if (s->ServerMode == false)
+ {
+ Lock(c->lock);
+ {
+ if (c->Udp->s != NULL)
+ {
+ sock = c->Udp->s;
+ if (sock != NULL)
+ {
+ AddRef(sock->ref);
+ }
+ }
+ }
+ Unlock(c->lock);
+
+ InitSockSet(&set);
+
+ if (sock != NULL)
+ {
+ AddSockSet(&set, sock);
+ }
+
+ Select(&set, SELECT_TIME, c1, c2);
+
+ if (sock != NULL)
+ {
+ IP ip;
+ UINT port;
+ UCHAR *buf;
+ UINT size;
+
+ while (true)
+ {
+ buf = c->RecvBuf;
+ size = RecvFrom(sock, &ip, &port, buf, RECV_BUF_SIZE);
+ if (size == 0 && sock->IgnoreRecvErr == false)
+ {
+ Debug("UDP Socket Disconnected.\n");
+ Lock(c->lock);
+ {
+ ReleaseSock(udp->s);
+ udp->s = NULL;
+ }
+ Unlock(c->lock);
+ break;
+ }
+ else if (size == SOCK_LATER)
+ {
+ break;
+ }
+ else
+ {
+ if (size)
+ {
+ PutUDPPacketData(c, buf, size);
+ }
+ }
+ }
+ }
+
+ if (sock != NULL)
+ {
+ Release(sock->ref);
+ }
+ }
+ else
+ {
+ Select(NULL, SELECT_TIME, c1, c2);
+ }
+ }
+ else if (c->Protocol == CONNECTION_HUB_SECURE_NAT)
+ {
+ SNAT *snat = c->Session->SecureNAT;
+ VH *v = snat->Nat->Virtual;
+ UINT size;
+ void *data;
+ UINT num;
+ UINT select_wait_time = SELECT_TIME_FOR_NAT;
+ UINT next_delay_packet_diff = 0;
+
+ if (snat->Nat != NULL && snat->Nat->Option.UseNat == false)
+ {
+ select_wait_time = SELECT_TIME;
+ }
+ else
+ {
+ if (snat->Nat != NULL)
+ {
+ LockList(v->NatTable);
+ {
+ if (LIST_NUM(v->NatTable) == 0 && LIST_NUM(v->ArpWaitTable) == 0)
+ {
+ select_wait_time = SELECT_TIME;
+ }
+ }
+ UnlockList(v->NatTable);
+ }
+ }
+
+ next_delay_packet_diff = GetNextDelayedPacketTickDiff(s);
+ select_wait_time = MIN(select_wait_time, next_delay_packet_diff);
+ num_delayed = LIST_NUM(s->DelayedPacketList);
+
+ if (no_spinlock_for_delay || select_wait_time >= 50 || num_delayed == false)
+ {
+ Select(NULL, (num_delayed == 0 ? select_wait_time :
+ (select_wait_time > 100 ? (select_wait_time - 100) : 1)), c1, c2);
+ }
+ else
+ {
+ YieldCpu();
+ }
+
+ num = 0;
+
+ if (hub != NULL)
+ {
+ NatSetHubOption(v, hub->Option);
+ }
+
+ // Receive a packet from the virtual machine
+ while (size = VirtualGetNextPacket(v, &data))
+ {
+ BLOCK *block;
+
+ // Generate packet block
+ block = NewBlock(data, size, 0);
+ if (block->Size > MAX_PACKET_SIZE)
+ {
+ // Packet size exceeded
+ FreeBlock(block);
+ }
+ else
+ {
+ // Add the data block to queue
+ InsertReveicedBlockToQueue(c, block);
+ }
+ num++;
+ if (num >= MAX_SEND_SOCKET_QUEUE_NUM)
+ {
+// WHERE;
+ break;
+ }
+ }
+ }
+ else if (c->Protocol == CONNECTION_HUB_LINK_SERVER)
+ {
+ // HUB Link
+ // Waiting Cancel simply
+ if (c->SendBlocks->num_item == 0)
+ {
+ UINT time = SELECT_TIME;
+ UINT next_delay_packet_diff = 0;
+
+ next_delay_packet_diff = GetNextDelayedPacketTickDiff(s);
+ time = MIN(time, next_delay_packet_diff);
+ num_delayed = LIST_NUM(s->DelayedPacketList);
+
+ if (no_spinlock_for_delay || time >= 50 || num_delayed == false)
+ {
+ Select(NULL, (num_delayed == 0 ? time : (time > 100 ? (time - 100) : 1)), c1, c2);
+ }
+ else
+ {
+ YieldCpu();
+ }
+ }
+ }
+ else if (c->Protocol == CONNECTION_HUB_LAYER3)
+ {
+ // Layer-3 switch session
+ L3IF *f = s->L3If;
+ UINT size, num = 0;
+ void *data;
+
+ if (f->SendQueue->num_item == 0)
+ {
+ UINT time = SELECT_TIME_FOR_NAT;
+ UINT next_delay_packet_diff = 0;
+
+ if (f->ArpWaitTable != NULL)
+ {
+ LockList(f->ArpWaitTable);
+ {
+ if (LIST_NUM(f->ArpWaitTable) == 0)
+ {
+ time = SELECT_TIME;
+ }
+ }
+ UnlockList(f->ArpWaitTable);
+ }
+
+ next_delay_packet_diff = GetNextDelayedPacketTickDiff(s);
+ time = MIN(time, next_delay_packet_diff);
+ num_delayed = LIST_NUM(s->DelayedPacketList);
+
+ if (no_spinlock_for_delay || time >= 50 || num_delayed == false)
+ {
+ Select(NULL, (num_delayed == 0 ? time : (time > 100 ? (time - 100) : 1)), c1, c2);
+ }
+ else
+ {
+ YieldCpu();
+ }
+ }
+
+ // Get the next packet
+ while (size = L3GetNextPacket(f, &data))
+ {
+ BLOCK *block = NewBlock(data, size, 0);
+ if (block->Size > MAX_PACKET_SIZE)
+ {
+ FreeBlock(block);
+ }
+ else
+ {
+ InsertReveicedBlockToQueue(c, block);
+ }
+
+ num++;
+ if (num >= MAX_SEND_SOCKET_QUEUE_NUM)
+ {
+ break;
+ }
+ }
+ }
+ else if (c->Protocol == CONNECTION_HUB_BRIDGE)
+ {
+ BRIDGE *b = c->Session->Bridge;
+
+ // Bridge session
+ if (b->Active)
+ {
+ void *data;
+ UINT ret;
+ UINT num = 0;
+ bool check_device_num = false;
+ UINT time = SELECT_TIME;
+ UINT next_delay_packet_diff = 0;
+
+ next_delay_packet_diff = GetNextDelayedPacketTickDiff(s);
+ time = MIN(time, next_delay_packet_diff);
+ num_delayed = LIST_NUM(s->DelayedPacketList);
+
+ // Bridge is operating
+ if (no_spinlock_for_delay || time >= 50 || num_delayed == false)
+ {
+ Select(NULL, (num_delayed == 0 ? time : (time > 100 ? (time - 100) : 1)), c1, c2);
+ }
+ else
+ {
+ YieldCpu();
+ }
+
+ if ((b->LastNumDeviceCheck + BRIDGE_NUM_DEVICE_CHECK_SPAN) <= Tick64())
+ {
+ check_device_num = true;
+ b->LastNumDeviceCheck = Tick64();
+ }
+
+ // Get the next packet from the bridge
+ while (true)
+ {
+ if (check_device_num && b->LastNumDevice != GetEthDeviceHash())
+ {
+ ret = INFINITE;
+ }
+ else
+ {
+ ret = EthGetPacket(b->Eth, &data);
+ }
+
+#ifdef OS_WIN32
+ if (c->Session != NULL)
+ {
+ c->Session->BridgeIsEthLoopbackBlock = false;
+ if (b->Eth != NULL && b->Eth->LoopbackBlock)
+ {
+ // Check whether The Ethernet device in the bridge
+ // has the ability to block the loopback packet
+ c->Session->BridgeIsEthLoopbackBlock = true;
+ }
+ }
+#endif // OS_WIN32
+
+ if (ret == INFINITE)
+ {
+ // Error occured: stop the bridge
+ CloseEth(b->Eth);
+ b->Eth = NULL;
+ b->Active = false;
+ ReleaseCancel(s->Cancel2);
+ s->Cancel2 = NULL;
+
+ HLog(s->Hub, "LH_BRIDGE_2", s->Name, b->Name);
+ Debug("Bridge Device Error.\n");
+
+ break;
+ }
+ else if (ret == 0)
+ {
+ // There is no more packet to receive
+ break;
+ }
+ else
+ {
+ if (hub != NULL && hub->Option != NULL && hub->Option->DisableUdpFilterForLocalBridgeNic == false &&
+ b->Eth != NULL && IsDhcpPacketForSpecificMac(data, ret, b->Eth->MacAddress))
+ {
+ // DHCP Packet is filtered.
+ Free(data);
+ }
+ else
+ {
+ // Add the packet to queue
+ BLOCK *block = NewBlock(data, ret, 0);
+
+ PROBE_DATA2("ConnectionReceive: NewBlock", data, ret);
+
+ if (ret > 1514)
+ {
+ NormalizeEthMtu(b, c, ret);
+ }
+
+ if (block->Size > MAX_PACKET_SIZE)
+ {
+ // Packet size exceeded
+ FreeBlock(block);
+ }
+ else
+ {
+ InsertReveicedBlockToQueue(c, block);
+ }
+ num++;
+ if (num >= MAX_SEND_SOCKET_QUEUE_NUM)
+ {
+ // WHERE;
+ break;
+ }
+ }
+ }
+ }
+ }
+ else
+ {
+ ETH *e;
+ // Bridge is stopped cureently
+ Select(NULL, SELECT_TIME, c1, NULL);
+
+ if (b->LastBridgeTry == 0 || (b->LastBridgeTry + BRIDGE_TRY_SPAN) <= Tick64())
+ {
+ b->LastBridgeTry = Tick64();
+
+ // Try to open an Ethernet device
+ e = OpenEth(b->Name, b->Local, b->TapMode, b->TapMacAddress);
+ if (e != NULL)
+ {
+ // Success
+ b->Eth = e;
+ b->Active = true;
+ b->LastNumDeviceCheck = Tick64();
+ b->LastNumDevice = GetEthDeviceHash();
+
+ // Update the NIC name of the bridge
+#ifdef OS_WIN32
+ if (IsEmptyStr(e->Title) == false)
+ {
+ StrCpy(b->Name, sizeof(b->Name), e->Title);
+
+ if (b->ParentLocalBridge != NULL)
+ {
+ StrCpy(b->ParentLocalBridge->DeviceName, sizeof(b->ParentLocalBridge->DeviceName), e->Title);
+ }
+ }
+#endif // OS_WIN32
+
+ Debug("Bridge Open Succeed.\n");
+
+ HLog(c->Session->Hub, "LH_BRIDGE_1", c->Session->Name, b->Name);
+
+ s->Cancel2 = EthGetCancel(b->Eth);
+ }
+ }
+ }
+ }
+}
+
+// Normalize the MTU of the Ethernet device
+void NormalizeEthMtu(BRIDGE *b, CONNECTION *c, UINT packet_size)
+{
+ // Validate arguments
+ if (packet_size == 0 || b == NULL || c == NULL)
+ {
+ return;
+ }
+
+ // Raise the MTU when the packet exceeds the current MTU
+ if (EthIsChangeMtuSupported(b->Eth))
+ {
+ UINT currentMtu = EthGetMtu(b->Eth);
+ if (currentMtu != 0)
+ {
+ if (packet_size > currentMtu)
+ {
+ bool ok = EthSetMtu(b->Eth, packet_size);
+
+ if (ok)
+ {
+ HLog(c->Session->Hub, "LH_SET_MTU", c->Session->Name,
+ b->Name, currentMtu, packet_size, packet_size);
+ }
+ else
+ {
+ UINT64 now = Tick64();
+
+ if (b->LastChangeMtuError == 0 ||
+ now >= (b->LastChangeMtuError + 60000ULL))
+ {
+ HLog(c->Session->Hub, "LH_SET_MTU_ERROR", c->Session->Name,
+ b->Name, currentMtu, packet_size, packet_size);
+
+ b->LastChangeMtuError = now;
+ }
+ }
+ }
+ }
+ }
+}
+
+// Release of the block
+void FreeBlock(BLOCK *b)
+{
+ // Validate arguments
+ if (b == NULL)
+ {
+ return;
+ }
+
+ Free(b->Buf);
+ Free(b);
+}
+
+// Create a new block
+BLOCK *NewBlock(void *data, UINT size, int compress)
+{
+ BLOCK *b;
+ // Validate arguments
+ if (data == NULL)
+ {
+ return NULL;
+ }
+
+ b = MallocFast(sizeof(BLOCK));
+
+ b->PriorityQoS = b->Ttl = b->Param1 = 0;
+
+ if (compress == 0)
+ {
+ // Uncompressed
+ b->Compressed = FALSE;
+ b->Buf = data;
+ b->Size = size;
+ b->SizeofData = size;
+ }
+ else if (compress == 1)
+ {
+ UINT max_size;
+
+ // Compressed
+ b->Compressed = TRUE;
+ max_size = CalcCompress(size);
+ b->Buf = MallocFast(max_size);
+ b->Size = Compress(b->Buf, max_size, data, size);
+ b->SizeofData = size;
+
+ // Discard old data block
+ Free(data);
+ }
+ else
+ {
+ // Expand
+ UINT max_size;
+
+ b->Compressed = FALSE;
+ max_size = MAX_PACKET_SIZE;
+ b->Buf = MallocFast(max_size);
+ b->Size = Uncompress(b->Buf, max_size, data, size);
+ b->SizeofData = size;
+
+ // Discard old data
+ Free(data);
+ }
+
+ return b;
+}
+
+// Create a TCP socket
+TCPSOCK *NewTcpSock(SOCK *s)
+{
+ TCPSOCK *ts;
+ // Validate arguments
+ if (s == NULL)
+ {
+ return NULL;
+ }
+
+ ts = ZeroMalloc(sizeof(TCPSOCK));
+
+ ts->Sock = s;
+ AddRef(s->ref);
+
+ ts->RecvFifo = NewFifo();
+ ts->SendFifo = NewFifo();
+ ts->EstablishedTick = ts->LastRecvTime = ts->LastCommTime = Tick64();
+
+ // Unset the time-out value
+ SetTimeout(s, TIMEOUT_INFINITE);
+
+ return ts;
+}
+
+// Set a encryption key for the TCP socket
+void InitTcpSockRc4Key(TCPSOCK *ts, bool server_mode)
+{
+ RC4_KEY_PAIR *pair;
+ CRYPT *c1, *c2;
+ // Validate arguments
+ if (ts == NULL)
+ {
+ return;
+ }
+
+ pair = &ts->Rc4KeyPair;
+
+ c1 = NewCrypt(pair->ClientToServerKey, sizeof(pair->ClientToServerKey));
+ c2 = NewCrypt(pair->ServerToClientKey, sizeof(pair->ServerToClientKey));
+
+ if (server_mode)
+ {
+ ts->RecvKey = c1;
+ ts->SendKey = c2;
+ }
+ else
+ {
+ ts->SendKey = c1;
+ ts->RecvKey = c2;
+ }
+}
+
+// Release of TCP socket
+void FreeTcpSock(TCPSOCK *ts)
+{
+ // Validate arguments
+ if (ts == NULL)
+ {
+ return;
+ }
+
+ Disconnect(ts->Sock);
+ ReleaseSock(ts->Sock);
+ ReleaseFifo(ts->RecvFifo);
+ ReleaseFifo(ts->SendFifo);
+
+ if (ts->SendKey)
+ {
+ FreeCrypt(ts->SendKey);
+ }
+ if (ts->RecvKey)
+ {
+ FreeCrypt(ts->RecvKey);
+ }
+
+ Free(ts);
+}
+
+// Exit the tunneling mode of connection
+void EndTunnelingMode(CONNECTION *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ // Protocol
+ if (c->Protocol == CONNECTION_TCP)
+ {
+ // TCP
+ DisconnectTcpSockets(c);
+ }
+ else
+ {
+ // UDP
+ DisconnectUDPSockets(c);
+ }
+}
+
+// Shift the connection to tunneling mode
+void StartTunnelingMode(CONNECTION *c)
+{
+ SOCK *s;
+ TCP *tcp;
+ TCPSOCK *ts;
+ IP ip;
+ UINT port;
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ tcp = c->Tcp;
+
+ // Protocol
+ if (c->Protocol == CONNECTION_TCP)
+ {
+ // TCP
+ s = c->FirstSock;
+
+ if (c->IsInProc)
+ {
+ AddRef(s->ref);
+ c->TubeSock = s;
+ }
+
+ ts = NewTcpSock(s);
+
+ if (c->ServerMode == false)
+ {
+ if (c->Session->ClientOption->ConnectionDisconnectSpan != 0)
+ {
+ ts->DisconnectTick = Tick64() + c->Session->ClientOption->ConnectionDisconnectSpan * (UINT64)1000;
+ }
+ }
+
+ LockList(tcp->TcpSockList);
+ {
+ Add(tcp->TcpSockList, ts);
+ }
+ UnlockList(tcp->TcpSockList);
+ ReleaseSock(s);
+ c->FirstSock = NULL;
+ }
+ else
+ {
+ // UDP
+ s = c->FirstSock;
+ Copy(&ip, &s->RemoteIP, sizeof(IP));
+ // May disconnect TCP connection at this point
+ c->FirstSock = NULL;
+ Disconnect(s);
+ ReleaseSock(s);
+
+ // Initialization of UDP structure
+ c->Udp = ZeroMalloc(sizeof(UDP));
+
+ if (c->ServerMode)
+ {
+ // Server mode
+ // Add an UDP Entry
+ AddUDPEntry(c->Cedar, c->Session);
+ c->Udp->s = NULL;
+ }
+ else
+ {
+ port = c->Session->ClientOption->PortUDP;
+ // Client mode
+ c->Udp->s = NewUDP(0);
+ // Write the IP address and port number
+ Copy(&c->Udp->ip, &ip, sizeof(IP));
+ c->Udp->port = port;
+ }
+
+ // Queue
+ c->Udp->BufferQueue = NewQueue();
+ }
+}
+
+// Generate a random value that depends on each machine
+UINT GetMachineRand()
+{
+ char pcname[MAX_SIZE];
+ UCHAR hash[SHA1_SIZE];
+
+ Zero(pcname, sizeof(pcname));
+ GetMachineName(pcname, sizeof(pcname));
+
+ HashSha1(hash, pcname, StrLen(pcname));
+
+ return READ_UINT(hash);
+}
+
+// Function that accepts a new connection
+void ConnectionAccept(CONNECTION *c)
+{
+ SOCK *s;
+ X *x;
+ K *k;
+ char tmp[128];
+ UCHAR openssl_check_buf[2];
+ char *error_details = NULL;
+ SERVER *server;
+ UCHAR *peek_buf = NULL;
+ UINT peek_buf_size = 1500;
+ char sni[128] = {0};
+ bool native1 = false; // Non-SNI flag
+ bool native2 = false; // Non-TLS flag
+ bool native3 = false; // SSLv2 flag
+ bool no_native = false;
+ UINT peek_size = 0;
+ UINT initial_timeout = CONNECTING_TIMEOUT;
+ bool no_peek_log = false;
+ UCHAR ctoken_hash[SHA1_SIZE];
+ bool no_write_ctoken_log = false;
+
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ Zero(ctoken_hash, sizeof(ctoken_hash));
+
+ peek_buf = ZeroMalloc(peek_buf_size);
+
+ Debug("ConnectionAccept()\n");
+
+ server = c->Cedar->Server;
+
+ // get a socket
+ s = c->FirstSock;
+ AddRef(s->ref);
+
+ Dec(c->Cedar->AcceptingSockets);
+
+ IPToStr(tmp, sizeof(tmp), &s->RemoteIP);
+
+ SLog(c->Cedar, "LS_CONNECTION_START_1", tmp, s->RemoteHostname, (IS_SPECIAL_PORT(s->RemotePort) ? 0 : s->RemotePort), c->Name);
+
+ // Timeout setting
+ initial_timeout += GetMachineRand() % (CONNECTING_TIMEOUT / 2);
+ SetTimeout(s, initial_timeout);
+
+
+ // Peek whether OpenSSL packet
+ if (s->IsReverseAcceptedSocket == false)
+ {
+ if (s->Type == SOCK_TCP && (c->Cedar != NULL && c->Cedar->Server != NULL && c->Cedar->Server->DisableOpenVPNServer == false))
+ {
+ if (Peek(s, openssl_check_buf, sizeof(openssl_check_buf)) == sizeof(openssl_check_buf))
+ {
+ if (OvsCheckTcpRecvBufIfOpenVPNProtocol(openssl_check_buf, sizeof(openssl_check_buf)))
+ {
+ // Detect OpenSSL packet
+ Debug("Detect OpenSSL on TCP!\n");
+
+ no_native = true;
+
+ if (OvsGetNoOpenVpnTcp() == false)
+ {
+ // Do OpenSSL processing
+ c->Type = CONNECTION_TYPE_OPENVPN;
+ if (OvsPerformTcpServer(c->Cedar, s) == false)
+ {
+ error_details = "OpenVPN_TCP_Aborted";
+ }
+ }
+
+ goto ERROR;
+ }
+ }
+ }
+
+
+ }
+
+ // Specify the encryption algorithm
+ Lock(c->Cedar->lock);
+ {
+ if (c->Cedar->CipherList != NULL)
+ {
+ SetWantToUseCipher(s, c->Cedar->CipherList);
+ }
+
+ x = CloneX(c->Cedar->ServerX);
+ k = CloneK(c->Cedar->ServerK);
+ }
+ Unlock(c->Cedar->lock);
+
+ // Start the SSL communication
+ Debug("StartSSL()\n");
+ if (StartSSL(s, x, k) == false)
+ {
+ // Failed
+ AddNoSsl(c->Cedar, &s->RemoteIP);
+ Debug("Failed to StartSSL.\n");
+ FreeX(x);
+ FreeK(k);
+
+ error_details = "StartSSL";
+
+ goto ERROR;
+ }
+
+ FreeX(x);
+ FreeK(k);
+
+ SLog(c->Cedar, "LS_SSL_START", c->Name, s->CipherName);
+
+ Copy(c->CToken_Hash, ctoken_hash, SHA1_SIZE);
+
+ // Accept the connection
+ if (ServerAccept(c) == false)
+ {
+ // Failed
+ Debug("ServerAccept Failed. Err = %u\n", c->Err);
+ goto ERROR;
+ }
+
+ if (c->flag1 == false)
+ {
+ Debug("%s %u c->flag1 == false\n", __FILE__, __LINE__);
+ Disconnect(s);
+ }
+ DelConnection(c->Cedar, c);
+ ReleaseSock(s);
+
+ Free(peek_buf);
+ return;
+
+ERROR:
+ Debug("ConnectionAccept() Error.\n");
+
+
+ Disconnect(s);
+ DelConnection(c->Cedar, c);
+ ReleaseSock(s);
+ Free(peek_buf);
+}
+
+// Stop the threads putting additional connection of all that are currently running
+void StopAllAdditionalConnectThread(CONNECTION *c)
+{
+ UINT i, num;
+ SOCK **socks;
+ THREAD **threads;
+ // Validate arguments
+ if (c == NULL || c->ServerMode != false)
+ {
+ return;
+ }
+
+ // Disconnect the socket first
+ LockList(c->ConnectingSocks);
+ {
+ num = LIST_NUM(c->ConnectingSocks);
+ socks = ToArray(c->ConnectingSocks);
+ DeleteAll(c->ConnectingSocks);
+ }
+ UnlockList(c->ConnectingSocks);
+ for (i = 0;i < num;i++)
+ {
+ Disconnect(socks[i]);
+ ReleaseSock(socks[i]);
+ }
+ Free(socks);
+
+ // Then, wait for the suspension of the thread
+ LockList(c->ConnectingThreads);
+ {
+ num = LIST_NUM(c->ConnectingThreads);
+ Debug("c->ConnectingThreads: %u\n", num);
+ threads = ToArray(c->ConnectingThreads);
+ DeleteAll(c->ConnectingThreads);
+ }
+ UnlockList(c->ConnectingThreads);
+ for (i = 0;i < num;i++)
+ {
+ WaitThread(threads[i], INFINITE);
+ ReleaseThread(threads[i]);
+ }
+ Free(threads);
+}
+
+// Stop the connection
+void StopConnection(CONNECTION *c, bool no_wait)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ Debug("Stop Connection: %s\n", c->Name);
+
+ // Stop flag
+ c->Halt = true;
+ Disconnect(c->FirstSock);
+
+ if (no_wait == false)
+ {
+ // Wait until the thread terminates
+ WaitThread(c->Thread, INFINITE);
+ }
+}
+
+// Close all the UDP socket
+void DisconnectUDPSockets(CONNECTION *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+ if (c->Protocol != CONNECTION_UDP)
+ {
+ return;
+ }
+
+ // Delete entry
+ if (c->ServerMode)
+ {
+ DelUDPEntry(c->Cedar, c->Session);
+ }
+
+ // Delete the UDP structure
+ if (c->Udp != NULL)
+ {
+ if (c->Udp->s != NULL)
+ {
+ ReleaseSock(c->Udp->s);
+ }
+ if (c->Udp->BufferQueue != NULL)
+ {
+ // Release of the queue
+ BUF *b;
+ while (b = GetNext(c->Udp->BufferQueue))
+ {
+ FreeBuf(b);
+ }
+ ReleaseQueue(c->Udp->BufferQueue);
+ }
+ Free(c->Udp);
+ c->Udp = NULL;
+ }
+
+ if (c->FirstSock != NULL)
+ {
+ Disconnect(c->FirstSock);
+ ReleaseSock(c->FirstSock);
+ c->FirstSock = NULL;
+ }
+}
+
+// Close all TCP connections
+void DisconnectTcpSockets(CONNECTION *c)
+{
+ UINT i, num;
+ TCP *tcp;
+ TCPSOCK **tcpsocks;
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+ if (c->Protocol != CONNECTION_TCP)
+ {
+ return;
+ }
+
+ tcp = c->Tcp;
+ LockList(tcp->TcpSockList);
+ {
+ tcpsocks = ToArray(tcp->TcpSockList);
+ num = LIST_NUM(tcp->TcpSockList);
+ DeleteAll(tcp->TcpSockList);
+ }
+ UnlockList(tcp->TcpSockList);
+
+ if (num != 0)
+ {
+ Debug("--- SOCKET STATUS ---\n");
+ for (i = 0;i < num;i++)
+ {
+ TCPSOCK *ts = tcpsocks[i];
+ Debug(" SOCK %2u: %u\n", i, ts->Sock->SendSize);
+ FreeTcpSock(ts);
+ }
+ }
+
+ Free(tcpsocks);
+}
+
+// Clean up of the connection
+void CleanupConnection(CONNECTION *c)
+{
+ UINT i, num;
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ DeleteLock(c->lock);
+ ReleaseCedar(c->Cedar);
+
+ switch (c->Protocol)
+ {
+ case CONNECTION_TCP:
+ // Release of TCP connection list
+ DisconnectTcpSockets(c);
+ break;
+
+ case CONNECTION_UDP:
+ break;
+ }
+
+ ReleaseList(c->Tcp->TcpSockList);
+ Free(c->Tcp);
+
+ ReleaseSock(c->FirstSock);
+ c->FirstSock = NULL;
+
+ ReleaseSock(c->TubeSock);
+ c->TubeSock = NULL;
+
+ ReleaseThread(c->Thread);
+ Free(c->Name);
+
+ // Release all the receive block and send block
+ if (c->SendBlocks)
+ {
+ LockQueue(c->SendBlocks);
+ {
+ BLOCK *b;
+ while (b = GetNext(c->SendBlocks))
+ {
+ FreeBlock(b);
+ }
+ }
+ UnlockQueue(c->SendBlocks);
+ }
+ if (c->SendBlocks2)
+ {
+ LockQueue(c->SendBlocks2);
+ {
+ BLOCK *b;
+ while (b = GetNext(c->SendBlocks2))
+ {
+ FreeBlock(b);
+ }
+ }
+ UnlockQueue(c->SendBlocks2);
+ }
+ if (c->ReceivedBlocks)
+ {
+ LockQueue(c->ReceivedBlocks);
+ {
+ BLOCK *b;
+ while (b = GetNext(c->ReceivedBlocks))
+ {
+ FreeBlock(b);
+ }
+ }
+ UnlockQueue(c->ReceivedBlocks);
+ }
+
+ if (c->ConnectingThreads)
+ {
+ THREAD **threads;
+ LockList(c->ConnectingThreads);
+ {
+ num = LIST_NUM(c->ConnectingThreads);
+ threads = ToArray(c->ConnectingThreads);
+ for (i = 0;i < num;i++)
+ {
+ ReleaseThread(threads[i]);
+ }
+ Free(threads);
+ }
+ UnlockList(c->ConnectingThreads);
+ ReleaseList(c->ConnectingThreads);
+ }
+
+ if (c->ConnectingSocks)
+ {
+ SOCK **socks;
+ LockList(c->ConnectingSocks);
+ {
+ num = LIST_NUM(c->ConnectingSocks);
+ socks = ToArray(c->ConnectingSocks);
+ for (i = 0;i < num;i++)
+ {
+ Disconnect(socks[i]);
+ ReleaseSock(socks[i]);
+ }
+ Free(socks);
+ }
+ UnlockList(c->ConnectingSocks);
+ ReleaseList(c->ConnectingSocks);
+ }
+
+ if (c->RecvBuf)
+ {
+ Free(c->RecvBuf);
+ }
+
+ if (c->ServerX != NULL)
+ {
+ FreeX(c->ServerX);
+ }
+
+ if (c->ClientX != NULL)
+ {
+ FreeX(c->ClientX);
+ }
+
+ ReleaseQueue(c->ReceivedBlocks);
+ ReleaseQueue(c->SendBlocks);
+ ReleaseQueue(c->SendBlocks2);
+
+ DeleteCounter(c->CurrentNumConnection);
+
+ if (c->CipherName != NULL)
+ {
+ Free(c->CipherName);
+ }
+
+ Free(c);
+}
+
+// Release of the connection
+void ReleaseConnection(CONNECTION *c)
+{
+ // Validate arguments
+ if (c == NULL)
+ {
+ return;
+ }
+
+ if (Release(c->ref) == 0)
+ {
+ CleanupConnection(c);
+ }
+}
+
+// Comparison of connection
+int CompareConnection(void *p1, void *p2)
+{
+ CONNECTION *c1, *c2;
+ if (p1 == NULL || p2 == NULL)
+ {
+ return 0;
+ }
+ c1 = *(CONNECTION **)p1;
+ c2 = *(CONNECTION **)p2;
+ if (c1 == NULL || c2 == NULL)
+ {
+ return 0;
+ }
+
+ return StrCmpi(c1->Name, c2->Name);
+}
+
+// Creating a server connection
+CONNECTION *NewServerConnection(CEDAR *cedar, SOCK *s, THREAD *t)
+{
+ CONNECTION *c;
+ // Validate arguments
+ if (cedar == NULL)
+ {
+ return NULL;
+ }
+
+ c = ZeroMalloc(sizeof(CONNECTION));
+ c->ConnectedTick = Tick64();
+ c->lock = NewLock();
+ c->ref = NewRef();
+ c->Cedar = cedar;
+ AddRef(c->Cedar->ref);
+ c->Protocol = CONNECTION_TCP;
+ c->Type = CONNECTION_TYPE_INIT;
+ c->FirstSock = s;
+ if (s != NULL)
+ {
+ AddRef(c->FirstSock->ref);
+ Copy(&c->ClientIp, &s->RemoteIP, sizeof(IP));
+ StrCpy(c->ClientHostname, sizeof(c->ClientHostname), s->RemoteHostname);
+ }
+ c->Tcp = ZeroMalloc(sizeof(TCP));
+ c->Tcp->TcpSockList = NewList(NULL);
+ c->ServerMode = true;
+ c->Status = CONNECTION_STATUS_ACCEPTED;
+ c->Name = CopyStr("INITING");
+ c->Thread = t;
+ AddRef(t->ref);
+ c->CurrentNumConnection = NewCounter();
+ Inc(c->CurrentNumConnection);
+
+ c->ServerVer = cedar->Version;
+ c->ServerBuild = cedar->Build;
+ StrCpy(c->ServerStr, sizeof(c->ServerStr), cedar->ServerStr);
+ GetServerProductName(cedar->Server, c->ServerStr, sizeof(c->ServerStr));
+
+ if (s != NULL && s->RemoteX != NULL)
+ {
+ c->ServerX = CloneX(s->RemoteX);
+ }
+
+ if (s != NULL && s->Type == SOCK_INPROC)
+ {
+ // In-process socket
+ c->IsInProc = true;
+ }
+
+ // Creating a Queue
+ c->ReceivedBlocks = NewQueue();
+ c->SendBlocks = NewQueue();
+ c->SendBlocks2 = NewQueue();
+
+ return c;
+}
+
+// Creating a Client Connection
+CONNECTION *NewClientConnection(SESSION *s)
+{
+ return NewClientConnectionEx(s, NULL, 0, 0);
+}
+CONNECTION *NewClientConnectionEx(SESSION *s, char *client_str, UINT client_ver, UINT client_build)
+{
+ CONNECTION *c;
+
+ // Initialization of CONNECTION object
+ c = ZeroMalloc(sizeof(CONNECTION));
+ c->ConnectedTick = Tick64();
+ c->lock = NewLock();
+ c->ref = NewRef();
+ c->Cedar = s->Cedar;
+ AddRef(c->Cedar->ref);
+ c->Protocol = CONNECTION_TCP;
+ c->Tcp = ZeroMalloc(sizeof(TCP));
+ c->Tcp->TcpSockList = NewList(NULL);
+ c->ServerMode = false;
+ c->Status = CONNECTION_STATUS_CONNECTING;
+ c->Name = CopyStr("CLIENT_CONNECTION");
+ c->Session = s;
+ c->CurrentNumConnection = NewCounter();
+ c->LastCounterResetTick = Tick64();
+ Inc(c->CurrentNumConnection);
+
+ c->ConnectingThreads = NewList(NULL);
+ c->ConnectingSocks = NewList(NULL);
+
+ if (client_str == NULL)
+ {
+ c->ClientVer = s->Cedar->Version;
+ c->ClientBuild = s->Cedar->Build;
+
+ if (c->Session->VirtualHost == false)
+ {
+ if (c->Session->LinkModeClient == false)
+ {
+ StrCpy(c->ClientStr, sizeof(c->ClientStr), CEDAR_CLIENT_STR);
+ }
+ else
+ {
+ StrCpy(c->ClientStr, sizeof(c->ClientStr), CEDAR_SERVER_LINK_STR);
+ }
+ }
+ else
+ {
+ StrCpy(c->ClientStr, sizeof(c->ClientStr), CEDAR_ROUTER_STR);
+ }
+ }
+ else
+ {
+ c->ClientVer = client_ver;
+ c->ClientBuild = client_build;
+ StrCpy(c->ClientStr, sizeof(c->ClientStr), client_str);
+ }
+
+ // Server name and port number
+ StrCpy(c->ServerName, sizeof(c->ServerName), s->ClientOption->Hostname);
+ c->ServerPort = s->ClientOption->Port;
+
+ // TLS 1.0 using flag
+ c->DontUseTls1 = s->ClientOption->NoTls1;
+
+ // Create queues
+ c->ReceivedBlocks = NewQueue();
+ c->SendBlocks = NewQueue();
+ c->SendBlocks2 = NewQueue();
+
+ return c;
+}
+// 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/
|