void Nasha256_compile(hashState256 *state)
{
int i;
uint_64t x[16],y[16],l1,l2;
B64 tmp;
uint_32t A1, B1, C1, A2, B2, C2;
uint_16t alpha1, beta1, gama1, alpha2, beta2, gama2;
uint_8t a1,b1,c1,a2,b2,c2,a3,b3,c3;
PutX(y,state);
LinTr16(y,x);
// computing the leaders l1 and l2
l1=x[0]+x[1];
l2=x[2]+x[3];
//computing the 8-bite words a1, b1, c1,a2,b2,c2,a3,b3,c3
tmp.bit64=x[4]+x[5];
a1=tmp.b8[7]; b1=tmp.b8[6]; c1=tmp.b8[5];
a2=tmp.b8[4]; b2=tmp.b8[3]; c2=tmp.b8[2];
a3=tmp.b8[1]; b3=tmp.b8[0]; c3=a1;
//computing the 16-bite words alpha1, beta1, gama1, alpha2, beta2, gama2
tmp.bit64=x[6]+x[7];
alpha1=tmp.bit16[3]; beta1=tmp.bit16[2]; gama1=tmp.bit16[1]; alpha2=tmp.bit16[0];
tmp.bit64=x[8]+x[9];
beta2=tmp.bit16[3]; gama2=tmp.bit16[2];
//computing the 32-bite words A1, B1, C1, A2, B2, C2
tmp.bit64=x[10]+x[11];
A1=tmp.bit32[1]; B1=tmp.bit32[0];
tmp.bit64=x[12]+x[13];
C1=tmp.bit32[1]; A2=tmp.bit32[0];
tmp.bit64=x[14]+x[15];
B2=tmp.bit32[1]; C2=tmp.bit32[0];
AE(l2,x,y,16,a1,b1,c1,a2,b2,c2,a3,b3,c3,alpha1, beta1, gama1,A1, B1, C1);
swap_64(y,16);
RAE(l1,y,x,15,a1,b1,c1,a2,b2,c2,a3,b3,c3,alpha2, beta2, gama2,A2, B2, C2);
/* Finally compute the hash digest (or/and the hash chain value) */
for (i=0;i<4;i++){
state->H[i]=x[(i<<2)+1];
state->hash[i]=x[(i<<2)+3];
}
}
BOOL TaskRegSave( VOID )
{
STRPTR data;
ULONG data_len = 0;
int items = 0;
BOOL rc = FALSE;
TaskReg *entry;
struct DupsLog *d;
ENTER();
// this is executed uSemaLock()'ed or Forbid()'ed
DBG_ASSERT(G && G->MagicID == GLOBAL_MAGIC);
if(!G || G->MagicID != GLOBAL_MAGIC)
{
SetIoErr(ERROR_OBJECT_WRONG_TYPE);
return FALSE;
}
if(IsMinListEmpty(G->TaskRegList))
{
DBG("The list is empty!\n");
return TRUE;
}
NewList((struct List *) &tr_dups );
ITERATE_LIST( G->TaskRegList, TaskReg *, entry)
{
if(IsDup(entry->TaskName,entry->AlertFlags,entry->ServerPort))
continue;
if((d = Malloc(sizeof(struct DupsLog))))
{
d->TaskName = entry->TaskName;
d->AlertFlags = entry->AlertFlags;
d->ServerPort = entry->ServerPort;
AddTail((struct List *)&tr_dups, (struct Node *)d);
}
items++;
data_len += entry->TaskNameLength;
#if DATABASE_RESERVED
data_len += DATABASE_RESERVED;
#endif
}
data_len += (sizeof(TaskReg) * items) + (sizeof(ULONG)*3);
DBG_VALUE(data_len);
if((data = Malloc(data_len)))
{
STRPTR ptr=data;
BPTR fd;
PutV( ptr, ULONG, DATABASE_ID);
PutV( ptr, ULONG, DATABASE_VERSION);
ITERATE_LIST( G->TaskRegList, TaskReg *, entry)
{
DBG_STRING(entry->TaskName);
if(IsDup(entry->TaskName,entry->AlertFlags,entry->ServerPort))
continue;
PutV( ptr, UWORD, entry->TaskNameLength );
PutX( ptr, entry->TaskNameLength, entry->TaskName );
PutV( ptr, BYTE, entry->allow );
PutV( ptr, BYTE, entry->remember );
PutV( ptr, ULONG, entry->RegTime.ds_Days );
PutV( ptr, ULONG, entry->RegTime.ds_Minute );
PutV( ptr, ULONG, entry->RegTime.ds_Tick );
PutV( ptr, ULONG, entry->ModTime.ds_Days );
PutV( ptr, ULONG, entry->ModTime.ds_Minute );
PutV( ptr, ULONG, entry->ModTime.ds_Tick );
PutV( ptr, ULONG, entry->accesses );
PutV( ptr, ULONG, entry->FileCRC );
PutV( ptr, UWORD, entry->CRCMods );
PutV( ptr, UWORD, entry->AlertFlags );
PutV( ptr, UWORD, entry->ServerPort );
#if DATABASE_RESERVED
ptr += DATABASE_RESERVED;
#endif
}
PutV( ptr, ULONG, DATABASE_EOFID );
if((fd = Open( DATABASE_FILE, MODE_NEWFILE )))
{
LONG len = (LONG)(ptr-data);
DBG_VALUE(len);
transcode( data, len );
rc = (Write( fd, data, len ) == len);
Close(fd);
}
Free(data);
}
