// Packet generation thread
void NullPacketGenerateThread(THREAD *t, void *param)
{
NULL_LAN *n = (NULL_LAN *)param;
// Validate arguments
if (t == NULL || param == NULL)
{
return;
}
while (true)
{
Wait(n->Event, Rand32() % NULL_PACKET_GENERATE_INTERVAL);
if (n->Halt)
{
break;
}
LockQueue(n->PacketQueue);
{
UCHAR *data;
BLOCK *b;
UINT size = Rand32() % 1500 + 14;
data = Malloc(size);
Copy(data, null_lan_broadcast_address, 6);
Copy(data + 6, n->MacAddr, 6);
b = NewBlock(data, size, 0);
InsertQueue(n->PacketQueue, b);
}
UnlockQueue(n->PacketQueue);
Cancel(n->Cancel);
}
}
uint64_t Rand64 (void)
{
uint64_t b;
b = Rand32();
b <<= 32;
b |= Rand32();
return (b);
}
HashType Rand64 (void)
{
HashType b;
b = Rand32();
b = b << 32;
b |= Rand32 ();
return (b);
}
// Packet generation thread
void NullPacketGenerateThread(THREAD *t, void *param)
{
NULL_LAN *n = (NULL_LAN *)param;
UINT64 end_tick = Tick64() + (UINT64)(60 * 1000);
UINT seq = 0;
// Validate arguments
if (t == NULL || param == NULL)
{
return;
}
while (true)
{
/*if (Tick64() >= end_tick)
{
break;
}*/
Wait(n->Event, Rand32() % 1500);
if (n->Halt)
{
break;
}
LockQueue(n->PacketQueue);
{
UCHAR *data;
BLOCK *b;
UINT size = Rand32() % 1500 + 14;
UCHAR dst_mac[6];
NullGenerateMacAddress(n->MacAddr, n->Id, seq);
//NullGenerateMacAddress(dst_mac, n->Id + 1, 0);
//StrToMac(dst_mac, "00-1B-21-A9-47-E6");
StrToMac(dst_mac, "00-AC-7A-EF-83-FD");
data = Malloc(size);
Copy(data, null_lan_broadcast_address, 6);
//Copy(data, dst_mac, 6);
Copy(data + 6, n->MacAddr, 6);
b = NewBlock(data, size, 0);
InsertQueue(n->PacketQueue, b);
}
UnlockQueue(n->PacketQueue);
Cancel(n->Cancel);
//seq++;
}
}
void Position::InitHashNumbers()
{
RandSeed32(42);
for (int f = 0; f < 64; f++)
{
for (int p = 0; p < 14; p++)
{
s_hash[f][p] = Rand64();
s_hashPawn[f][p] = (p == PW || p == PB)? Rand32() : 0;
}
}
s_hashSide[0] = 0;
s_hashSide[1] = Rand64();
}
uint32 MyRandom::RandInt(uint32 nMin, uint32 nMax)
{
if( nMin == nMax)
return nMin;
if( nMin > nMax )
std::swap( nMin, nMax);
if( nMax - nMin + 1 <= 0 )
return nMin;
if( nMax <= RAND_MAX )
return nMin + Rand() % (nMax - nMin + 1);
else
return nMin + Rand32() % ( nMax - nMin + 1);
}
void CTranspositionTable::InitializeHashKey(){
int i,j;
srand((unsigned)time(NULL));
for (i = 0; i < PIECE_COUNT; ++i)
for (j = 0; j < BOARD_NUMBER; ++j){
if (!CChessUtil::InBoard(j))
continue;
m_hash_key_32[i][j] = Rand32();
m_hash_key_64[i][j] = Rand64();
}
m_ptt[0] = new HashItem[HASH_SIZE];
m_ptt[1] = new HashItem[HASH_SIZE];
}
void CTranspositionTable::InitializeHashKey()
{
int i,j,k;
srand((unsigned)time(NULL));
//填充随机数组
for(i=0;i<15;i++)
for(j=0;j<10;j++)
for(k=0;k<9;k++)
{
m_nHashKey32[i][j][k]=Rand32();
m_ulHashKey64[i][j][k]=Rand64();
}
//申请置换表所用空间。1M*2个条目，读者也可指定其他大小
m_pTT[0]=new HASHITEM[1024*1024];//用于存放取极大值的节点数据
m_pTT[1]=new HASHITEM[1024*1024];//用于存放取极小值的节点数据
}
// Process the timer interrupt
void SstpProcessInterrupt(SSTP_SERVER *s)
{
// Validate arguments
if (s == NULL)
{
return;
}
s->Now = Tick64();
s->FlushRecvTube = false;
// Process the received packet
while (true)
{
BLOCK *b = GetNext(s->RecvQueue);
SSTP_PACKET *p;
if (b == NULL)
{
break;
}
p = SstpParsePacket(b->Buf, b->Size);
if (p == NULL)
{
// Disconnect the SSTP since a bad packet received
SstpAbort(s);
}
else
{
// Process the received packet
SstpProcessPacket(s, p);
SstpFreePacket(p);
}
FreeBlock(b);
}
if (s->FlushRecvTube)
{
TubeFlush(s->TubeRecv);
}
// Transmit a packet that the PPP module is trying to send via the SSTP
while (true)
{
TUBEDATA *d = TubeRecvAsync(s->TubeSend);
SSTP_PACKET *p;
if (d == NULL)
{
break;
}
p = SstpNewDataPacket(d->Data, d->DataSize);
SstpSendPacket(s, p);
SstpFreePacket(p);
FreeTubeData(d);
}
if (s->Status == SSTP_SERVER_STATUS_ESTABLISHED)
{
if (s->Disconnecting == false && s->Aborting == false)
{
// Periodic transmission of Echo Request
if (s->NextSendEchoRequestTick == 0 || s->NextSendEchoRequestTick <= s->Now)
{
UINT64 next_interval = (UINT64)(SSTP_ECHO_SEND_INTERVAL_MIN + Rand32() % (SSTP_ECHO_SEND_INTERVAL_MAX - SSTP_ECHO_SEND_INTERVAL_MIN));
SSTP_PACKET *p;
s->NextSendEchoRequestTick = s->Now + next_interval;
AddInterrupt(s->Interrupt, s->NextSendEchoRequestTick);
p = SstpNewControlPacket(SSTP_MSG_ECHO_REQUEST);
SstpSendPacket(s, p);
SstpFreePacket(p);
}
}
}
if ((s->LastRecvTick + (UINT64)SSTP_TIMEOUT) <= s->Now)
{
// Disconnect the SSTP because a timeout occurred
SstpAbort(s);
s->Disconnected = true;
}
if (IsTubeConnected(s->TubeRecv) == false || IsTubeConnected(s->TubeSend) == false)
{
// Disconnect the SSTP since the PPP module is disconnected
SstpDisconnect(s);
}
if (s->Disconnecting)
{
// Normal disconnection process
if (s->DisconnectSent == false)
{
// Send a Disconnect
SSTP_PACKET *ret = SstpNewControlPacket(s->DisconnectRecved ? SSTP_MSG_CALL_DISCONNECT_ACK : SSTP_MSG_CALL_DISCONNECT);
SstpSendPacket(s, ret);
SstpFreePacket(ret);
s->DisconnectSent = true;
}
}
if (s->Aborting)
{
// Abnormal disconnection processing
if (s->AbortSent == false)
{
// Send the Abort
SSTP_PACKET *ret = SstpNewControlPacket(SSTP_MSG_CALL_ABORT);
SstpSendPacket(s, ret);
SstpFreePacket(ret);
s->AbortSent = true;
}
}
if (s->DisconnectSent && s->DisconnectRecved)
{
// Disconnect after exchanging the Disconnect each other
s->Disconnected = true;
}
if (s->AbortSent && s->AbortReceived)
{
// Disconnect after exchanging the Abort each other
s->Disconnected = true;
}
}
// Create a new UDP acceleration function
UDP_ACCEL *NewUdpAccel(CEDAR *cedar, IP *ip, bool client_mode, bool random_port, bool no_nat_t)
{
UDP_ACCEL *a;
SOCK *s;
UINT max_udp_size;
bool is_in_cedar_port_list = false;
if (IsZeroIP(ip))
{
ip = NULL;
}
if (client_mode || random_port)
{
// Use a appropriate vacant port number in the case of using random port or client mode
s = NewUDPEx3(0, ip);
}
else
{
// Specify in the range in the case of server mode
UINT i;
s = NULL;
LockList(cedar->UdpPortList);
{
for (i = UDP_SERVER_PORT_LOWER;i <= UDP_SERVER_PORT_HIGHER;i++)
{
if (IsIntInList(cedar->UdpPortList, i) == false)
{
s = NewUDPEx3(i, ip);
if (s != NULL)
{
is_in_cedar_port_list = true;
break;
}
}
}
if (s == NULL)
{
// Leave the port selection to the OS because the available port is not found within the range
s = NewUDPEx3(0, ip);
}
if (s != NULL && is_in_cedar_port_list)
{
AddIntDistinct(cedar->UdpPortList, i);
}
}
UnlockList(cedar->UdpPortList);
}
if (s == NULL)
{
return NULL;
}
a = ZeroMalloc(sizeof(UDP_ACCEL));
a->Cedar = cedar;
AddRef(a->Cedar->ref);
a->NoNatT = no_nat_t;
a->NatT_TranId = Rand64();
a->CreatedTick = Tick64();
a->IsInCedarPortList = is_in_cedar_port_list;
a->ClientMode = client_mode;
a->Now = Tick64();
a->UdpSock = s;
Rand(a->MyKey, sizeof(a->MyKey));
Rand(a->YourKey, sizeof(a->YourKey));
Copy(&a->MyIp, ip, sizeof(IP));
a->MyPort = s->LocalPort;
a->IsIPv6 = IsIP6(ip);
if (a->IsIPv6)
{
a->NoNatT = true;
}
a->RecvBlockQueue = NewQueue();
Rand(a->NextIv, sizeof(a->NextIv));
do
{
a->MyCookie = Rand32();
}
while (a->MyCookie == 0);
do
{
a->YourCookie = Rand32();
}
while (a->MyCookie == 0 || a->MyCookie == a->YourCookie);
// Calculate the maximum transmittable UDP packet size
max_udp_size = MTU_FOR_PPPOE;
if (a->IsIPv6 == false)
{
// IPv4
max_udp_size -= 20;
}
else
{
// IPv6
max_udp_size -= 40;
}
// UDP
max_udp_size -= 8;
a->MaxUdpPacketSize = max_udp_size;
Debug("Udp Accel My Port = %u\n", a->MyPort);
// Initialize the NAT-T server IP address acquisition thread
a->NatT_Lock = NewLock();
a->NatT_HaltEvent = NewEvent();
if (a->NoNatT == false)
{
a->NatT_GetIpThread = NewThread(NatT_GetIpThread, a);
}
return a;
}
