int HashFile(char **Return, char *Type, char *Path, int Encoding)
{
THash *Hash;
STREAM *S;
char *Tempstr=NULL;
int result;
S=STREAMOpenFile(Path,O_RDONLY);
if (! S) return(FALSE);
Hash=HashInit(Type);
if (! Hash)
{
STREAMClose(S);
return(FALSE);
}
Tempstr=SetStrLen(Tempstr,4096);
result=STREAMReadBytes(S,Tempstr,4096);
while (result !=EOF)
{
Hash->Update(Hash, Tempstr, result);
result=STREAMReadBytes(S,Tempstr,4096);
}
DestroyString(Tempstr);
STREAMClose(S);
result=Hash->Finish(Hash, Encoding, Return);
HashDestroy(Hash);
return(result);
}
/*------------------------------------------------------------------
*
*------------------------------------------------------------------*/
int main(void)
{
Hash *iHash;
int i;
int counter;
iHash = HashCreate(sizeof(int),3,compareFunc,hashFunc,NULL);
for (i= 1; i<10; i++)
HashAdd(iHash,&i);
for (i=20; i>10; i--)
HashAdd(iHash,&i);
for (i=0; i<=21; i++)
if (!HashFind(iHash,&i))
printf("didn't find %d\n",i);
counter = 1;
HashIterate(iHash,iterateFunc,&counter);
for (i=-1; i<5; i++)
HashDelete(iHash,&i);
for (i=21; i>15; i--)
HashDelete(iHash,&i);
counter = 1;
HashIterate(iHash,iterateFunc,&counter);
HashDestroy(iHash);
return 0;
}
THash *HashInit(char *Type)
{
THash *Hash=NULL;
Hash=(THash *) calloc(1,sizeof(THash));
Hash->Type=CopyStr(Hash->Type,Type);
if (strcasecmp(Type,"md5")==0) HashInitMD5(Hash, 0);
else if (strcasecmp(Type,"sha")==0) HashInitSHA(Hash, 0);
else if (strcasecmp(Type,"sha1")==0) HashInitSHA(Hash, 0);
else if (strcasecmp(Type,"sha256")==0) HashInitSHA(Hash, 256);
else if (strcasecmp(Type,"sha512")==0) HashInitSHA(Hash, 512);
else if (strcasecmp(Type,"whirl")==0) HashInitWhirlpool(Hash, 0);
else if (strcasecmp(Type,"whirlpool")==0) HashInitWhirlpool(Hash, 0);
else if (strcasecmp(Type,"jh-224")==0) HashInitJH(Hash,224);
else if (strcasecmp(Type,"jh-256")==0) HashInitJH(Hash,256);
else if (strcasecmp(Type,"jh-384")==0) HashInitJH(Hash,384);
else if (strcasecmp(Type,"jh-512")==0) HashInitJH(Hash,512);
//else if (strcasecmp(Type,"crc32")==0) HashInitCRC(Hash, 0);
else if (strncasecmp(Type,"hmac-",5)==0) HMACInit(Hash);
else
{
HashDestroy(Hash);
Hash=NULL;
}
return(Hash);
}
int HashFinish(THash *Hash, int Encoding, char **Return)
{
char *Token=NULL, *Bytes=NULL, *Hashed=NULL, *ptr;
int len;
ptr=GetToken(Hash->Type, "\\S", &Token, 0);
len=Hash->Finish(Hash, &Bytes);
while (StrValid(ptr))
{
ptr=GetToken(ptr, "\\S", &Token, 0);
len=HashBytes(&Hashed, Token, Bytes, len, 0);
Bytes=SetStrLen(Bytes, len);
memcpy(Bytes,Hashed,len);
}
if (Encoding > 0)
{
*Return=EncodeBytes(*Return, Bytes, len, Encoding);
len=StrLen(*Return);
}
else
{
*Return=SetStrLen(*Return, len);
memcpy(*Return, Bytes, len);
}
HashDestroy(Hash);
DestroyString(Hashed);
DestroyString(Token);
DestroyString(Bytes);
return(len);
}
void OperatorDBDestroy(OperatorDB* _odb)
{
if (NULL == _odb)
{
LOG_WARN_PRINT("%s", "Attempted to destroy uninitialized operator database");
return;
}
HashForEach(_odb->m_map, FreeOperators, NULL);
HashDestroy(_odb->m_map);
free(_odb);
LOG_DEBUG_PRINT("%s", "Successfully destroyed operator database");
}
int HashBytes(char **Return, char *Type, char *text, int len, int Encoding)
{
THash *Hash;
int result;
Hash=HashInit(Type);
if (! Hash) return(0);
Hash->Update(Hash, text, len);
result=Hash->Finish(Hash, Encoding, Return);
HashDestroy(Hash);
return(result);
}
/*------------------------------------------------------------------
* atexit processing
*------------------------------------------------------------------*/
static void RunAtExit(void)
{
if (!AllDone)
fprintf(stderr,"%s : Program terminated.\n",PROGRAM_NAME);
/*---------------------------------------------------------------
* erase any temporary files we might have open
*---------------------------------------------------------------*/
if (!AllDone)
fprintf(stderr,"%s : Cleaning up temporary files.\n",PROGRAM_NAME);
ListIterate(info.fileList,(ListIterateFunc *)CleanUpFileList,&info);
/*---------------------------------------------------------------
* destroy file list
*---------------------------------------------------------------*/
ListDestroy(info.fileList);
/*---------------------------------------------------------------
* destroy hash tables
*---------------------------------------------------------------*/
HashDestroy(info.identHash);
HashDestroy(info.reservedHash);
/*---------------------------------------------------------------
* destroy function list
*---------------------------------------------------------------*/
ListIterate(info.funcTree,(ListIterateFunc *)CleanUpFuncList,&info);
ListDestroy(info.funcTree);
/*---------------------------------------------------------------
* dump memory (if debug enabled
*---------------------------------------------------------------*/
#if defined(__DEBUG_ALLOC__)
_dump_allocated(0);
#endif
}
HASH *HashInit(const char *Type)
{
HASH *Hash=NULL;
char *InitialType=NULL;
Hash=(HASH *) calloc(1,sizeof(HASH));
Hash->Type=CopyStr(Hash->Type,Type);
strrep(Hash->Type,',',' ');
GetToken(Hash->Type,"\\S",&InitialType,0);
if (strcasecmp(InitialType,"md5")==0) HashInitMD5(Hash, 0);
else if (strcasecmp(InitialType,"sha")==0) HashInitSHA(Hash, 0);
else if (strcasecmp(InitialType,"sha1")==0) HashInitSHA(Hash, 0);
else if (strcasecmp(InitialType,"sha256")==0) HashInitSHA(Hash, 256);
else if (strcasecmp(InitialType,"sha512")==0) HashInitSHA(Hash, 512);
else if (strcasecmp(InitialType,"sha-256")==0) HashInitSHA(Hash, 256);
else if (strcasecmp(InitialType,"sha-512")==0) HashInitSHA(Hash, 512);
else if (strcasecmp(InitialType,"whirl")==0) HashInitWhirlpool(Hash, 0);
else if (strcasecmp(InitialType,"whirlpool")==0) HashInitWhirlpool(Hash, 0);
else if (strcasecmp(InitialType,"jh224")==0) HashInitJH(Hash,224);
else if (strcasecmp(InitialType,"jh256")==0) HashInitJH(Hash,256);
else if (strcasecmp(InitialType,"jh384")==0) HashInitJH(Hash,384);
else if (strcasecmp(InitialType,"jh512")==0) HashInitJH(Hash,512);
else if (strcasecmp(InitialType,"jh-224")==0) HashInitJH(Hash,224);
else if (strcasecmp(InitialType,"jh-256")==0) HashInitJH(Hash,256);
else if (strcasecmp(InitialType,"jh-384")==0) HashInitJH(Hash,384);
else if (strcasecmp(InitialType,"jh-512")==0) HashInitJH(Hash,512);
//else if (strcasecmp(InitialType,"crc32")==0) HashInitCRC(Hash, 0);
else if (strncasecmp(InitialType,"hmac-",5)==0) HMACInit(Hash);
else
{
RaiseError(0, "HashInit", "Unsupported Hash Type '%s'",InitialType);
HashDestroy(Hash);
Hash=NULL;
}
DestroyString(InitialType);
return(Hash);
}
/*------------------------------------------------------------------
* create hash table
*------------------------------------------------------------------*/
Hash *HashCreate(
int itemSize,
int buckets,
HashFunc *hashFunc,
ListCompareFunc *cmpFunc,
ListNoMemFunc *memFunc
)
{
Hash *hash;
int i;
/*---------------------------------------------------------------
* sanity check
*---------------------------------------------------------------*/
if (!itemSize || !buckets || !cmpFunc || !hashFunc)
return NULL;
/*---------------------------------------------------------------
* allocate table structure
*---------------------------------------------------------------*/
hash = malloc(sizeof(List));
if (!hash)
{
if (memFunc)
memFunc();
return NULL;
}
/*---------------------------------------------------------------
* fill in fields
*---------------------------------------------------------------*/
hash->itemSize = itemSize;
hash->buckets = buckets;
hash->hashFunc = hashFunc;
hash->memFunc = memFunc;
/*---------------------------------------------------------------
* allocate buckets
*---------------------------------------------------------------*/
hash->bucket = malloc(buckets*sizeof(List *));
if (!hash->bucket)
{
free(hash);
if (memFunc)
memFunc();
return NULL;
}
/*---------------------------------------------------------------
* initialize to zero
*---------------------------------------------------------------*/
memset(hash->bucket,0,buckets*sizeof(List *));
/*---------------------------------------------------------------
* initialize buckets
*---------------------------------------------------------------*/
for (i=0; i<buckets; i++)
{
hash->bucket[i] = ListCreate(itemSize,cmpFunc,memFunc);
if (!hash->bucket[i])
{
HashDestroy(hash);
if (memFunc)
memFunc();
}
}
/*---------------------------------------------------------------
* return
*---------------------------------------------------------------*/
return hash;
}
