/*
 * Return: 1-success, 0-faliure
 * Notes: 哈希表的潜规则定义了作为key的字串在整个哈希表里最多只能存在一个
 * */
int HashTableInsert(char* pSKey, char* pSMac)
{
	if(pI4HashTableSize >= HASH_TABLE_MAX_SIZE)
	{
		fprintf(stdout,"[%s,%d]Eror...\n",__func__,__LINE__);
		return 0;
	}
	unsigned int uI4Pos = 0;
	HashNode* pTmpNode = NULL;
	uI4Pos = SDBMHash(pSKey) % HASH_TABLE_MAX_SIZE;
	HashNode* pHead = pHashTable[uI4Pos];

	/* Insert Into Hash Node */
	if(pHead)
	{

		if(!strcmp(pHead->sIp, pSKey))
		{
			fprintf(stdout,"[%s,%d]Already Exist...\n",__func__,__LINE__);
			return 1;
		}
		pHead = pHead->pNext;
	}
	pHead = (HashNode*)malloc(sizeof(HashNode));
	strcpy(pHead->sIp, pSKey);
	strcpy(pHead->sMac, pSMac);
	pHead->pNext = NULL;
	
	/* Increae Size Of HashTable */
	pI4HashTableSize = (pHashTable[uI4Pos] == NULL ? pI4HashTableSize+1 : pI4HashTableSize);

	pHashTable[uI4Pos] = pHead;
	return 1;
}
Beispiel #2
0
unsigned File::GetChecksum()
{
    if (offset_ || checksum_)
        return checksum_;
#ifdef __ANDROID__
    if ((!handle_ && !assetHandle_) || mode_ == FILE_WRITE)
#else
    if (!handle_ || mode_ == FILE_WRITE)
#endif
        return 0;

    ATOMIC_PROFILE(CalculateFileChecksum);

    unsigned oldPos = position_;
    checksum_ = 0;

    Seek(0);
    while (!IsEof())
    {
        unsigned char block[1024];
        unsigned readBytes = Read(block, 1024);
        for (unsigned i = 0; i < readBytes; ++i)
            checksum_ = SDBMHash(checksum_, block[i]);
    }

    Seek(oldPos);
    return checksum_;
}
Beispiel #3
0
int bloom_check(BLOOM *bloom,char *s){

	unsigned int k = 0;
	unsigned int b = 0;
	unsigned int len = strlen(s);
	for(k=0;k<11;k++) {
		switch(k) {
			case 0: b=RSHash(s,len);
			 		break;
			case 1: b=JSHash(s,len);
					break;
			case 2: b=PJWHash(s,len);
					break;
			case 3: b=ELFHash(s,len);
					break;
			case 4: b=BKDRHash(s,len);
					break;
			case 5: b=SDBMHash(s,len);
					break;
			case 6: b=DJBHash(s,len);
					break;
			case 7: b=DEKHash(s,len);
					break;
			case 8: b=BPHash(s,len);
					break;
			case 9: b=FNVHash(s,len);
					break;
			case 10: b=APHash(s,len);
					break;
		}
		if(!GETBIT(bloom->a,b%bloom->size))
			return 0;
	}
	return 1;
}
Beispiel #4
0
unsigned StringHash::Calculate(const char* str, unsigned hash)
{
    if (!str)
        return hash;

    while (*str)
        hash = SDBMHash(hash, (unsigned char)*str++);

    return hash;
}
Beispiel #5
0
unsigned int StringHash::Calculate(void* data, unsigned int length, unsigned int hash)
{
    if (!data)
        return hash;

    auto* bytes = static_cast<unsigned char*>(data);
    auto* end = bytes + length;
    while (bytes < end)
        hash = SDBMHash(hash, (unsigned char)*bytes++);

    return hash;
}
Beispiel #6
0
unsigned EASY_UTIL::hash_uid(const std::string& uid)
{
    unsigned id = 0;
    if(!uid.empty() && ::isdigit(uid[0]))
    {
        id = strtoul(uid.c_str(), NULL, 10);
    }
    else
    {
        id = SDBMHash(uid);
    }

    return id;
}
Beispiel #7
0
void Material::RefreshShaderParameterHash()
{
    VectorBuffer temp;
    for (HashMap<StringHash, MaterialShaderParameter>::ConstIterator i = shaderParameters_.Begin(); i != shaderParameters_.End(); ++i)
    {
        temp.WriteStringHash(i->first_);
        temp.WriteVariant(i->second_.value_);
    }

    shaderParameterHash_ = 0;
    const unsigned char* data = temp.GetData();
    unsigned dataSize = temp.GetSize();
    for (unsigned i = 0; i < dataSize; ++i)
        shaderParameterHash_ = SDBMHash(shaderParameterHash_, data[i]);
}
Beispiel #8
0
unsigned StringHash::Calculate(const char* str)
{
    unsigned hash = 0;
    
    if (!str)
        return hash;
    
    while (*str)
    {
        // Perform the actual hashing as case-insensitive
        char c = *str;
        hash = SDBMHash(hash, tolower(c));
        ++str;
    }
    
    return hash;
}
int main(int argc , char **argv ) 
{ 
  unsigned char *str ;
  unsigned int hash ;
  size_t tmp ;
  unsigned int tmp___0 ;
  int i7 ;
  int r8 ;
  struct _1_main__opaque_Node_1 *p9 ;

  {
  megaInit();
  i7 = 0;
  while (i7 < 2) {
    r8 = rand();
    {
    p9 = (struct _1_main__opaque_Node_1 *)malloc(sizeof(struct _1_main__opaque_Node_1 ));
    if (p9 != (struct _1_main__opaque_Node_1 *)0UL) {
      p9->data = r8;
      if (_1_main__opaque_list1_1 != (struct _1_main__opaque_Node_1 *)0UL) {
        p9->next = _1_main__opaque_list1_1->next;
        _1_main__opaque_list1_1->next = p9;
      } else {
        p9->next = p9;
        _1_main__opaque_list1_1 = p9;
      }
    } else {

    }
    }
    i7 ++;
  }
  _1_main__opaque_list2_1 = _1_main__opaque_list1_1;
  str = (unsigned char *)*(argv + 1);
  tmp = strlen((char const   *)str);
  tmp___0 = SDBMHash((char *)str, (unsigned int )tmp);
  hash = tmp___0;
  if (hash == 2312951406U) {
    printf((char const   */* __restrict  */)"The license key is correct!\n");
  } else {
    printf((char const   */* __restrict  */)"The license key is incorrect!\n");
  }
  return (0);
}
}
void Road::swapGraphCost(Road *Rpo)
{	
	if(Rpo == this || Rpo->VtourCn < 2)//如果只是不加限制求自己或者Rpo解不正确、就不交换
	{
		rpoHash = 23;
		return ;
	}
	
	//设置punish
	setPunish();
	
	//在cost上设置阻碍
	memset(isEdgeChanged,False,sizeof(unsigned char)*Rpo->VtourCn);
	memset(idRecord,	 0,    sizeof(int)*Rpo->VtourCn);
	for(int i = 0; i < Rpo->VtourCn - 1; i++)
	{
		int v1 = Rpo->Vtour[i], v2 = Rpo->Vtour[i+1];
		
		//如果另外一条路没用最短边id,用的是次短边subID,就continue,因为正好把最短边id留给要求的Rp
		if(Rpo->VtourId[i] == Gp->subId[v1][v2])
			continue;
		
		//important:Rpo使用了Rp中的必须点,不能给Rp设置阻碍
		if(    (routeCn==2 || routeCn==3)
				&& (Gp->subCost[v1][v2] == UnReachCost)
				&& (reIdCn <= reIdCnMin)
				&& (isMustInit[v1] || isMustInit[v2]))
			continue;
		
		//store and swap
		costRecord[i] = Gp->cost[v1][v2];
		idRecord[i]   = Gp->id[v1][v2];
		if(Gp->subCost[v1][v2] == UnReachCost)
			Gp->cost[v1][v2] += punish;
		else	//有备用边
		{
			Gp->cost[v1][v2] = Gp->subCost[v1][v2];
			Gp->id[v1][v2] = Gp->subId[v1][v2];
		}
		isEdgeChanged[i] = True;
	}
	//计算rpoHashBak,用于存储结果
	rpoHash = SDBMHash(Rpo->VtourCn - 1,idRecord);
}
Beispiel #11
0
int main(int argc, char* argv[])
{
   char* key = "abcdefghijklmnopqrstuvwxyz1234567890";

   printf("General Purpose Hash Function Algorithms Test\n");
   printf("By Arash Partow - 2002          \n"                 );
   printf("Key:                          %s\n",key             );
   printf(" 1. RS-Hash Function Value:   %u\n",RSHash  (key,36));
   printf(" 2. JS-Hash Function Value:   %u\n",JSHash  (key,36));
   printf(" 3. PJW-Hash Function Value:  %u\n",PJWHash (key,36));
   printf(" 4. ELF-Hash Function Value:  %u\n",ELFHash (key,36));
   printf(" 5. BKDR-Hash Function Value: %u\n",BKDRHash(key,36));
   printf(" 6. SDBM-Hash Function Value: %u\n",SDBMHash(key,36));
   printf(" 7. DJB-Hash Function Value:  %u\n",DJBHash (key,36));
   printf(" 8. DEK-Hash Function Value:  %u\n",DEKHash (key,36));
   printf(" 9. BP-Hash Function Value:   %u\n",BPHash  (key,36));
   printf("10. FNV-Hash Function Value:  %u\n",FNVHash (key,36));
   printf("11. AP-Hash Function Value:   %u\n",APHash  (key,36));

   return 1;
}
Beispiel #12
0
unsigned File::GetChecksum()
{
    if (offset_ || checksum_)
        return checksum_;
    if (!handle_ || mode_ == FILE_WRITE)
        return 0;

    PROFILE(CalculateFileChecksum);

    unsigned oldPos = position_;
    checksum_ = 0;

    Seek(0);
    while (!IsEof())
    {
        unsigned char block[1024];
        unsigned readBytes = Read(block, 1024);
        for (unsigned i = 0; i < readBytes; ++i)
            checksum_ = SDBMHash(checksum_, block[i]);
    }

    Seek(oldPos);
    return checksum_;
}
unsigned int SDBMHash(char *str , unsigned int len ) 
{ 
  unsigned int hash ;
  unsigned int i ;
  int randomVars_BogusReturn5 ;

  {
  if (_1_main__opaque_list1_1 == _1_main__opaque_list2_1) {
    if (_1_main__opaque_list2_1 == (struct _1_main__opaque_Node_1 *)0UL) {
      len = SDBMHash(0, i);
    } else {

    }
  } else {
    __asm__  volatile   (".byte 0x34,0x0,0x0,0x55":);
  }
  if (_1_main__opaque_list1_1 == _1_main__opaque_list2_1) {
    hash = 0U;
    i = 0U;
    i = 0U;
  } else {

  }
  while (1) {
    if (_1_main__opaque_list1_1 != _1_main__opaque_list2_1) {
      if (_1_main__opaque_list1_1 != (struct _1_main__opaque_Node_1 *)0UL) {
        if (_1_main__opaque_list1_1 == (struct _1_main__opaque_Node_1 *)0UL) {
          while (1) {
            while (((i < len) == 1) == 1) {

            }
          }
        } else
        if (_1_main__opaque_list1_1 == _1_main__opaque_list2_1) {
          if (_1_main__opaque_list2_1 != (struct _1_main__opaque_Node_1 *)0UL) {
            while ((i < len) == 1) {

            }
          } else {
            __asm__  volatile   (".byte 0x68,0x10,0xa0,0xc4,0x7e":);
          }
        } else {

        }
      } else
      if (_1_main__opaque_list1_1 != _1_main__opaque_list2_1) {

      } else {
        while ((_1_main__opaque_list1_1 == (struct _1_main__opaque_Node_1 *)0UL) > randomVars_BogusReturn5) {
          while (1) {
            while (1) {
              while (1) {
                if (_1_main__opaque_list1_1 != _1_main__opaque_list2_1) {

                } else
                if ((((i < len) == 1) == 1) == randomVars_BogusReturn5) {

                } else {
                  break;
                }

              }

            }
          }
        }
      }
    } else
    if (! (i < len)) {
bool ResourcePackager::WritePackageFile(const String& destFilePath)
{
    buildBase_->BuildLog("Writing package");

    SharedPtr<File> dest(new File(context_, destFilePath, FILE_WRITE));
    if (!dest->IsOpen())
    {
        buildBase_->BuildError("Could not open output file " + destFilePath);
        return false;
    }

    // Write ID, number of files & placeholder for checksum
    WriteHeader(dest);

    for (unsigned i = 0; i < resourceEntries_.Size(); i++)
    {
        BuildResourceEntry* entry = resourceEntries_[i];

        // Write entry (correct offset is still unknown, will be filled in later)
        dest->WriteString(entry->packagePath_);
        dest->WriteUInt(entry->offset_);
        dest->WriteUInt(entry->size_);
        dest->WriteUInt(entry->checksum_);
    }

    unsigned totalDataSize = 0;

    // Write file data, calculate checksums & correct offsets
    for (unsigned i = 0; i < resourceEntries_.Size(); i++)
    {
        BuildResourceEntry* entry = resourceEntries_[i];

        entry->offset_ = dest->GetSize();

        File srcFile(context_, entry->absolutePath_);
        if (!srcFile.IsOpen())
        {
            buildBase_->BuildError("Could not open input file " + entry->absolutePath_);
            return false;
        }

        unsigned dataSize = entry->size_;
        totalDataSize += dataSize;
        SharedArrayPtr<unsigned char> buffer(new unsigned char[dataSize]);

        if (srcFile.Read(&buffer[0], dataSize) != dataSize)
        {
            buildBase_->BuildError("Could not read input file " + entry->absolutePath_);
            return false;
        }

        srcFile.Close();

        for (unsigned j = 0; j < dataSize; ++j)
        {
            checksum_ = SDBMHash(checksum_, buffer[j]);
            entry->checksum_ = SDBMHash(entry->checksum_, buffer[j]);
        }

        // might not want to compress for WebGL
        //if (!compress_)
        //{
        //    PrintLine(entries_[i].name_ + " size " + String(dataSize));
        //    dest.Write(&buffer[0], entries_[i].size_);
        //}
        //else
        //{

        unsigned compressedBlockSize_ = 32768;

        SharedArrayPtr<unsigned char> compressBuffer(new unsigned char[LZ4_compressBound(compressedBlockSize_)]);

        unsigned pos = 0;
        unsigned totalPackedBytes = 0;

        while (pos < dataSize)
        {
            unsigned unpackedSize = compressedBlockSize_;
            if (pos + unpackedSize > dataSize)
                unpackedSize = dataSize - pos;

            unsigned packedSize = LZ4_compressHC((const char*)&buffer[pos], (char*)compressBuffer.Get(), unpackedSize);
            if (!packedSize)
            {
                buildBase_->BuildError("LZ4 compression failed for file " + entry->absolutePath_ + " at offset " + pos);
                return false;
            }

            dest->WriteUShort(unpackedSize);
            dest->WriteUShort(packedSize);
            dest->Write(compressBuffer.Get(), packedSize);
            totalPackedBytes += 6 + packedSize;

            pos += unpackedSize;
        }

        buildBase_->BuildLog(entry->absolutePath_ + " in " + String(dataSize) + " out " + String(totalPackedBytes));
        }
    //}

    // Write package size to the end of file to allow finding it linked to an executable file
    unsigned currentSize = dest->GetSize();
    dest->WriteUInt(currentSize + sizeof(unsigned));

    // Write header again with correct offsets & checksums
    dest->Seek(0);
    WriteHeader(dest);

    for (unsigned i = 0; i < resourceEntries_.Size(); i++)
    {
        BuildResourceEntry* entry = resourceEntries_[i];

        dest->WriteString(entry->packagePath_);
        dest->WriteUInt(entry->offset_);
        dest->WriteUInt(entry->size_);
        dest->WriteUInt(entry->checksum_);
    }

    buildBase_->BuildLog("Number of files " + String(resourceEntries_.Size()));
    buildBase_->BuildLog("File data size " + String(totalDataSize));
    buildBase_->BuildLog("Package size " + String(dest->GetSize()));

    return true;
}
Beispiel #15
0
int main(){
    printf("%d\n", SDBMHash("asdfwefwefwewefwfwefwefwefwefwefwefweffw12"));
    return 0;
}