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(); }
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];//用于存放取极小值的节点数据 }
void fill_buffer(void *buf, size_t len, void *pattern, size_t pattern_len, const unsigned int pattern_type) { size_t i, j; unsigned char *ucharbuf = buf; OFF_T *off_tbuf = buf; unsigned char *ucharpattern = pattern; OFF_T *poff_tpattern = pattern; OFF_T off_tpat, off_tpat2; switch (pattern_type) { /* the pattern type should only be one of the following */ case CLD_FLG_CPTYPE : /* Will fill buffer with counting pattern 0x00 thru 0xff */ for (i=0;i<len;i++) ucharbuf[i] = (unsigned char) (i & 0xff); break; case CLD_FLG_FPTYPE : /* arrange data to go on the wire correctly */ off_tpat = 0; for (j=0;j<(sizeof(OFF_T)/pattern_len);j++) for (i=0;i<pattern_len;++i) #ifdef WINDOWS off_tpat |= (((OFF_T)(ucharpattern[i])) << 8*(7-((j*pattern_len)+i))); #endif #ifdef AIX off_tpat |= (((OFF_T)(ucharpattern[(8-pattern_len)+i])) << 8*(7-((j*pattern_len)+i))); #endif #ifdef LINUX #if __BYTE_ORDER == __LITTLE_ENDIAN off_tpat |= (((OFF_T)(ucharpattern[i])) << 8*(7-((j*pattern_len)+i))); #else off_tpat |= (((OFF_T)(ucharpattern[(8-pattern_len)+i])) << 8*(7-((j*pattern_len)+i))); #endif #endif /* fill buffer with fixed pattern */ for (i=0;i<len/8;i++) *(off_tbuf+i) = off_tpat; break; case CLD_FLG_LPTYPE : off_tpat2 = *poff_tpattern; for (j=0;j<len;j++) { /* arrange data to go on the wire correctly */ ucharpattern = (unsigned char *) &off_tpat2; off_tpat = 0; for (i=0;i<pattern_len;i++) #ifdef WINDOWS off_tpat |= (((OFF_T)(ucharpattern[i])) << 8*(7-i)); #endif #ifdef AIX off_tpat |= (((OFF_T)(ucharpattern[(8-pattern_len)+i])) << 8*(7-i)); #endif #ifdef LINUX #if __BYTE_ORDER == __LITTLE_ENDIAN off_tpat |= (((OFF_T)(ucharpattern[i])) << 8*(7-i)); #else off_tpat |= (((OFF_T)(ucharpattern[(8-pattern_len)+i])) << 8*(7-i)); #endif #endif /* fill buffer with lba number */ for (i=0;i<BLK_SIZE/8;i++) { *(off_tbuf+i+(j*(BLK_SIZE/8))) = off_tpat; } off_tpat2++; } break; case CLD_FLG_RPTYPE : /* Will fill buffer with a random pattern. * Unfortunatly, every LBA, 512 bytes of data will be * the same random data set, this is due to the LBA * boundary requirement of disktest. This should be fixed * at some point... */ for (i=0;i<BLK_SIZE/sizeof(OFF_T);i++) *(off_tbuf+i) = Rand64(); for (i=BLK_SIZE;i<len;i+=BLK_SIZE) memcpy((ucharbuf+i), ucharbuf, BLK_SIZE); break; default : printf("Unknown fill pattern\n"); exit(1); } }
UINT DCGetMyIpMain(DDNS_CLIENT *c, bool ipv6, char *dst, UINT dst_size, bool use_ssl, char *replace_v6) { char *url; char url2[MAX_SIZE]; UINT ret = ERR_INTERNAL_ERROR; URL_DATA data; BUF *recv; BUF *cert_hash; // Validate arguments if (dst == NULL || c == NULL) { return ERR_INTERNAL_ERROR; } if (ipv6 == false) { url = DDNS_URL2_V4_GLOBAL; if (IsUseAlternativeHostname()) { url = DDNS_URL2_V4_ALT; } } else { url = DDNS_URL2_V6_GLOBAL; if (IsUseAlternativeHostname()) { url = DDNS_URL2_V6_ALT; } if (replace_v6) { url = replace_v6; } } Format(url2, sizeof(url2), "%s?v=%I64u", url, Rand64()); if (use_ssl) { ReplaceStr(url2, sizeof(url2), url2, "http://", "https://"); } if (ParseUrl(&data, url2, false, NULL) == false) { return ERR_INTERNAL_ERROR; } cert_hash = StrToBin(DDNS_CERT_HASH); recv = HttpRequest(&data, (ipv6 ? NULL : &c->InternetSetting), DDNS_CONNECT_TIMEOUT, DDNS_COMM_TIMEOUT, &ret, false, NULL, NULL, NULL, ((cert_hash != NULL && cert_hash->Size == SHA1_SIZE) ? cert_hash->Buf : NULL)); FreeBuf(cert_hash); if (recv != NULL) { char *str = ZeroMalloc(recv->Size + 1); Copy(str, recv->Buf, recv->Size); if (StartWith(str, "IP=") == false) { ret = ERR_PROTOCOL_ERROR; } else { StrCpy(dst, dst_size, str + 3); ret = ERR_NO_ERROR; } Free(str); FreeBuf(recv); } if (IsUseAlternativeHostname() == false) { if (ret == ERR_CONNECT_FAILED) { if (ipv6 && replace_v6 == NULL && use_ssl == false) { UINT type = DetectFletsType(); if (type & FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE && ret != ERR_NO_ERROR) { ret = DCGetMyIpMain(c, ipv6, dst, dst_size, use_ssl, DDNS_REPLACE_URL2_FOR_EAST_BFLETS); } if (type & FLETS_DETECT_TYPE_EAST_NGN_PRIVATE && ret != ERR_NO_ERROR) { ret = DCGetMyIpMain(c, ipv6, dst, dst_size, use_ssl, DDNS_REPLACE_URL2_FOR_EAST_NGN); } if (type & FLETS_DETECT_TYPE_WEST_NGN_PRIVATE && ret != ERR_NO_ERROR) { ret = DCGetMyIpMain(c, ipv6, dst, dst_size, use_ssl, DDNS_REPLACE_URL2_FOR_WEST_NGN); } } } } return ret; }
// Execution of registration UINT DCRegister(DDNS_CLIENT *c, bool ipv6, DDNS_REGISTER_PARAM *p, char *replace_v6) { char *url; char url2[MAX_SIZE]; char url3[MAX_SIZE]; PACK *req, *ret; char key_str[MAX_SIZE]; UCHAR machine_key[SHA1_SIZE]; char machine_key_str[MAX_SIZE]; char machine_name[MAX_SIZE]; BUF *cert_hash; UINT err = ERR_INTERNAL_ERROR; UCHAR key_hash[SHA1_SIZE]; char key_hash_str[MAX_SIZE]; bool use_azure = false; char current_azure_ip[MAX_SIZE]; INTERNET_SETTING t; UINT build = 0; bool use_https = false; bool use_vgs = false; // Validate arguments if (c == NULL) { return ERR_INTERNAL_ERROR; } Zero(current_azure_ip, sizeof(current_azure_ip)); GetCurrentMachineIpProcessHash(machine_key); BinToStr(machine_key_str, sizeof(machine_key_str), machine_key, sizeof(machine_key)); GetMachineHostName(machine_name, sizeof(machine_name)); StrLower(machine_name); if (ipv6 == false) { url = DDNS_URL_V4_GLOBAL; if (IsUseAlternativeHostname()) { url = DDNS_URL_V4_ALT; } } else { url = DDNS_URL_V6_GLOBAL; if (IsUseAlternativeHostname()) { url = DDNS_URL_V6_ALT; } if (replace_v6) { url = replace_v6; } } Zero(&t, sizeof(t)); if (ipv6 == false) { // Proxy Setting Copy(&t, &c->InternetSetting, sizeof(INTERNET_SETTING)); } if (ipv6 == false) { // Get the current status of the VPN Azure Client if (c->Cedar->Server != NULL) { AZURE_CLIENT *ac = c->Cedar->Server->AzureClient; if (ac != NULL) { use_azure = SiIsAzureEnabled(c->Cedar->Server); if (use_azure) { Lock(ac->Lock); { StrCpy(current_azure_ip, sizeof(current_azure_ip), ac->ConnectingAzureIp); } Unlock(ac->Lock); } } } } req = NewPack(); BinToStr(key_str, sizeof(key_str), c->Key, sizeof(c->Key)); StrUpper(key_str); PackAddStr(req, "key", key_str); // Build Number build = c->Cedar->Build; PackAddInt(req, "build", build); PackAddInt(req, "osinfo", GetOsInfo()->OsType); PackAddInt(req, "is_64bit", Is64()); #ifdef OS_WIN32 PackAddInt(req, "is_windows_64bit", MsIs64BitWindows()); #endif // OS_WIN32 PackAddBool(req, "is_softether", true); PackAddBool(req, "is_packetix", false); PackAddStr(req, "machine_key", machine_key_str); PackAddStr(req, "machine_name", machine_name); PackAddInt(req, "lasterror_ipv4", c->Err_IPv4_GetMyIp); PackAddInt(req, "lasterror_ipv6", c->Err_IPv6_GetMyIp); PackAddBool(req, "use_azure", use_azure); PackAddStr(req, "product_str", CEDAR_PRODUCT_STR); PackAddInt(req, "ddns_protocol_version", DDNS_VERSION); if (use_azure) { Debug("current_azure_ip = %s\n", current_azure_ip); PackAddStr(req, "current_azure_ip", current_azure_ip); } HashSha1(key_hash, key_str, StrLen(key_str)); BinToStr(key_hash_str, sizeof(key_hash_str), key_hash, sizeof(key_hash)); StrLower(key_hash_str); if (p != NULL) { if (IsEmptyStr(p->NewHostname) == false) { PackAddStr(req, "new_hostname", p->NewHostname); } } cert_hash = StrToBin(DDNS_CERT_HASH); Format(url2, sizeof(url2), "%s?v=%I64u", url, Rand64()); Format(url3, sizeof(url3), url2, key_hash_str[0], key_hash_str[1], key_hash_str[2], key_hash_str[3]); if (use_https == false) { ReplaceStr(url3, sizeof(url3), url3, "https://", "http://"); } ReplaceStr(url3, sizeof(url3), url3, ".servers", ".open.servers"); Debug("WpcCall: %s\n", url3); ret = WpcCallEx(url3, &t, DDNS_CONNECT_TIMEOUT, DDNS_COMM_TIMEOUT, "register", req, NULL, NULL, ((cert_hash != NULL && cert_hash->Size == SHA1_SIZE) ? cert_hash->Buf : NULL), NULL, DDNS_RPC_MAX_RECV_SIZE); Debug("WpcCall Ret: %u\n", ret); FreeBuf(cert_hash); FreePack(req); err = GetErrorFromPack(ret); ExtractAndApplyDynList(ret); // Status update Lock(c->Lock); { if (err == ERR_NO_ERROR) { char snat_t[MAX_SIZE]; char current_region[128]; // Current host name PackGetStr(ret, "current_hostname", c->CurrentHostName, sizeof(c->CurrentHostName)); PackGetStr(ret, "current_fqdn", c->CurrentFqdn, sizeof(c->CurrentFqdn)); PackGetStr(ret, "current_ipv4", c->CurrentIPv4, sizeof(c->CurrentIPv4)); PackGetStr(ret, "current_ipv6", c->CurrentIPv6, sizeof(c->CurrentIPv6)); PackGetStr(ret, "dns_suffix", c->DnsSuffix, sizeof(c->DnsSuffix)); PackGetStr(ret, "current_region", current_region, sizeof(current_region)); // SecureNAT connectivity check parameters Zero(snat_t, sizeof(snat_t)); PackGetStr(ret, "snat_t", snat_t, sizeof(snat_t)); NnSetSecureNatTargetHostname(snat_t); if (ipv6 == false) { char cert_hash[MAX_SIZE]; PackGetStr(ret, "current_azure_ip", c->CurrentAzureIp, sizeof(c->CurrentAzureIp)); c->CurrentAzureTimestamp = PackGetInt64(ret, "current_azure_timestamp"); PackGetStr(ret, "current_azure_signature", c->CurrentAzureSignature, sizeof(c->CurrentAzureSignature)); Zero(cert_hash, sizeof(cert_hash)); PackGetStr(ret, "azure_cert_hash", cert_hash, sizeof(cert_hash)); if (IsEmptyStr(cert_hash) == false) { StrCpy(c->AzureCertHash, sizeof(c->AzureCertHash), cert_hash); } } StrCpy(c->Cedar->CurrentDDnsFqdn, sizeof(c->Cedar->CurrentDDnsFqdn), c->CurrentFqdn); Debug("current_hostname=%s, current_fqdn=%s, current_ipv4=%s, current_ipv6=%s, current_azure_ip=%s, CurrentAzureTimestamp=%I64u, CurrentAzureSignature=%s, CertHash=%s\n", c->CurrentHostName, c->CurrentFqdn, c->CurrentIPv4, c->CurrentIPv6, c->CurrentAzureIp, c->CurrentAzureTimestamp, c->CurrentAzureSignature, c->AzureCertHash); if (IsEmptyStr(current_region) == false) { // Update the current region SiUpdateCurrentRegion(c->Cedar, current_region, false); } } } Unlock(c->Lock); if (IsEmptyStr(c->CurrentFqdn) == false) { SetCurrentDDnsFqdn(c->CurrentFqdn); } FreePack(ret); UniDebug(L"DCRegister Error: %s\n", _E(err)); if (err == ERR_DUPLICATE_DDNS_KEY) { // Key duplication DCGenNewKey(c->Key); c->KeyChanged = true; } if (err == ERR_DISCONNECTED) { err = ERR_DDNS_DISCONNECTED; } if (IsUseAlternativeHostname() == false) { if (err == ERR_CONNECT_FAILED) { if (ipv6 && replace_v6 == NULL) { UINT type = DetectFletsType(); if (type & FLETS_DETECT_TYPE_EAST_BFLETS_PRIVATE && err != ERR_NO_ERROR) { err = DCRegister(c, ipv6, p, DDNS_REPLACE_URL_FOR_EAST_BFLETS); } if (type & FLETS_DETECT_TYPE_EAST_NGN_PRIVATE && err != ERR_NO_ERROR) { err = DCRegister(c, ipv6, p, DDNS_REPLACE_URL_FOR_EAST_NGN); } if (type & FLETS_DETECT_TYPE_WEST_NGN_PRIVATE && err != ERR_NO_ERROR) { err = DCRegister(c, ipv6, p, DDNS_REPLACE_URL_FOR_WEST_NGN); } } } } return err; }
// 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; }