/*
* adfWriteRootBlock
*
*
*/
RETCODE adfWriteRootBlock(struct Volume* vol, long nSect, struct bRootBlock* root)
{
unsigned char buf[LOGICAL_BLOCK_SIZE];
unsigned long newSum;
root->type = T_HEADER;
root->headerKey = 0L;
root->highSeq = 0L;
root->hashTableSize = HT_SIZE;
root->firstData = 0L;
/* checkSum, hashTable */
/* bmflag */
/* bmPages, bmExt */
root->nextSameHash = 0L;
root->parent = 0L;
root->secType = ST_ROOT;
memcpy(buf, root, LOGICAL_BLOCK_SIZE);
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_ROOT);
#endif
newSum = adfNormalSum(buf,20,LOGICAL_BLOCK_SIZE);
swLong(buf+20, newSum);
/* *(unsigned long*)(buf+20) = swapLong((unsigned char*)&newSum);*/
/* dumpBlock(buf);*/
if (adfWriteBlock(vol, nSect, buf)!=RC_OK)
return RC_ERROR;
/*printf("adfWriteRootBlock %ld\n",nSect);*/
return RC_OK;
}
/*
* adfWriteBootBlock
*
*
* write bootcode ?
*/
RETCODE
adfWriteBootBlock(struct Volume* vol, struct bBootBlock* boot)
{
unsigned char buf[LOGICAL_BLOCK_SIZE*2];
unsigned long newSum;
boot->dosType[0] = 'D';
boot->dosType[1] = 'O';
boot->dosType[2] = 'S';
memcpy(buf, boot, LOGICAL_BLOCK_SIZE*2);
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_BOOT);
#endif
if (boot->rootBlock==880 || boot->data[0]!=0) {
newSum = adfBootSum(buf);
/*fprintf(stderr,"sum %x %x\n",newSum,adfBootSum2(buf));*/
swLong(buf+4,newSum);
/* *(unsigned long*)(buf+4) = swapLong((unsigned char*)&newSum);*/
}
/* dumpBlock(buf);
dumpBlock(buf+512);
*/
if (adfWriteBlock(vol, 0, buf)!=RC_OK)
return RC_ERROR;
if (adfWriteBlock(vol, 1, buf+512)!=RC_OK)
return RC_ERROR;
/*puts("adfWriteBootBlock");*/
return RC_OK;
}
/*
* adfWriteDataBlock
*
*/
RETCODE adfWriteDataBlock(struct Volume *vol, SECTNUM nSect, void *data)
{
unsigned char buf[512];
uint32_t newSum;
struct bOFSDataBlock *dataB;
RETCODE rc = RC_OK;
newSum = 0L;
if (isOFS(vol->dosType)) {
dataB = (struct bOFSDataBlock *)data;
dataB->type = T_DATA;
memcpy(buf,dataB,512);
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_DATA);
#endif
newSum = adfNormalSum(buf,20,512);
swLong(buf+20,newSum);
/* *(int32_t*)(buf+20) = swapLong((unsigned char*)&newSum);*/
adfWriteBlock(vol,nSect,buf);
}
else {
adfWriteBlock(vol,nSect,data);
}
/*printf("adfWriteDataBlock %ld\n",nSect);*/
return rc;
}
/*
* adfPutCacheEntry
*
* remplaces one cache entry at the p offset, and returns its length
*/
int adfPutCacheEntry( struct bDirCacheBlock *dirc, int *p, struct CacheEntry *cEntry)
{
int ptr, l;
ptr = *p;
#ifdef LITT_ENDIAN
swLong(dirc->records+ptr, cEntry->header);
swLong(dirc->records+ptr+4, cEntry->size);
swLong(dirc->records+ptr+8, cEntry->protect);
swShort(dirc->records+ptr+16, cEntry->days);
swShort(dirc->records+ptr+18, cEntry->mins);
swShort(dirc->records+ptr+20, cEntry->ticks);
#else
memcpy(dirc->records+ptr,&(cEntry->header),4);
memcpy(dirc->records+ptr+4,&(cEntry->size),4);
memcpy(dirc->records+ptr+8,&(cEntry->protect),4);
memcpy(dirc->records+ptr+16,&(cEntry->days),2);
memcpy(dirc->records+ptr+18,&(cEntry->mins),2);
memcpy(dirc->records+ptr+20,&(cEntry->ticks),2);
#endif
dirc->records[ptr+22] =(signed char)cEntry->type;
dirc->records[ptr+23] = cEntry->nLen;
memcpy(dirc->records+ptr+24, cEntry->name, cEntry->nLen);
dirc->records[ptr+24+cEntry->nLen] = cEntry->cLen;
memcpy(dirc->records+ptr+24+cEntry->nLen+1, cEntry->comm, cEntry->cLen);
/*puts("adfPutCacheEntry");*/
l = 25+cEntry->nLen+cEntry->cLen;
if ((l%2)==0)
return l;
else {
dirc->records[ptr+l] =(char)0;
return l+1;
}
/* ptr%2 must be == 0, if l%2==0, (ptr+l)%2==0 */
}
/*
* adfWriteRDSKblock
*
*/
RETCODE
adfWriteRDSKblock(struct Device *dev, struct bRDSKblock* rdsk)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
struct nativeFunctions *nFct;
RETCODE rc2, rc = RC_OK;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWriteRDSKblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(rdsk->id,"RDSK",4);
rdsk->size = sizeof(struct bRDSKblock)/sizeof(int32_t);
rdsk->blockSize = LOGICAL_BLOCK_SIZE;
rdsk->badBlockList = -1;
strncpy(rdsk->diskVendor,"ADFlib ",8);
strncpy(rdsk->diskProduct,"harddisk.adf ",16);
strncpy(rdsk->diskRevision,"v1.0",4);
memcpy(buf, rdsk, sizeof(struct bRDSKblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_RDSK);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8, newSum);
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc2=(*nFct->adfNativeWriteSector)(dev, 0, LOGICAL_BLOCK_SIZE, buf);
else
rc2=adfWriteDumpSector(dev, 0, LOGICAL_BLOCK_SIZE, buf);
if (rc2!=RC_OK)
return RC_ERROR;
return rc;
}
/*
* adfWriteEntryBlock
*
*/
RETCODE adfWriteEntryBlock(struct Volume* vol, SECTNUM nSect, struct bEntryBlock *ent)
{
unsigned char buf[512];
uint32_t newSum;
memcpy(buf, ent, sizeof(struct bEntryBlock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_ENTRY);
#endif
newSum = adfNormalSum(buf,20,sizeof(struct bEntryBlock));
swLong(buf+20, newSum);
if (adfWriteBlock(vol, nSect, buf)!=RC_OK)
return RC_ERROR;
return RC_OK;
}
/*
* adfWritePARTblock
*
*/
RETCODE
adfWritePARTblock(struct Device *dev, int32_t nSect, struct bPARTblock* part)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
struct nativeFunctions *nFct;
RETCODE rc2, rc = RC_OK;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWritePARTblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(part->id,"PART",4);
part->size = sizeof(struct bPARTblock)/sizeof(int32_t);
part->blockSize = LOGICAL_BLOCK_SIZE;
part->vectorSize = 16;
part->blockSize = 128;
part->sectorsPerBlock = 1;
part->dosReserved = 2;
memcpy(buf, part, sizeof(struct bPARTblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_PART);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8, newSum);
/* *(int32_t*)(buf+8) = swapLong((uint8_t*)&newSum);*/
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc2=(*nFct->adfNativeWriteSector)(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
else
rc2=adfWriteDumpSector(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
if (rc2!=RC_OK)
return RC_ERROR;
return rc;
}
/*
* adfWriteBitmapBlock
*
* OK
*/
RETCODE
adfWriteBitmapBlock(struct Volume* vol, SECTNUM nSect, struct bBitmapBlock* bitm)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
memcpy(buf,bitm,LOGICAL_BLOCK_SIZE);
#ifdef LITT_ENDIAN
/* little to big */
swapEndian(buf, SWBL_BITMAP);
#endif
newSum = adfNormalSum(buf, 0, LOGICAL_BLOCK_SIZE);
swLong(buf,newSum);
/* dumpBlock((uint8_t*)buf);*/
if (adfWriteBlock(vol, nSect, (uint8_t*)buf)!=RC_OK)
return RC_ERROR;
return RC_OK;
}
/*
* adfWriteFileHdrBlock
*
*/
RETCODE adfWriteFileHdrBlock(struct Volume *vol, SECTNUM nSect, struct bFileHeaderBlock* fhdr)
{
unsigned char buf[512];
uint32_t newSum;
RETCODE rc = RC_OK;
/*printf("adfWriteFileHdrBlock %ld\n",nSect);*/
fhdr->type = T_HEADER;
fhdr->dataSize = 0;
fhdr->secType = ST_FILE;
memcpy(buf, fhdr, sizeof(struct bFileHeaderBlock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_FILE);
#endif
newSum = adfNormalSum(buf,20,sizeof(struct bFileHeaderBlock));
swLong(buf+20, newSum);
/* *(uint32_t*)(buf+20) = swapLong((unsigned char*)&newSum);*/
adfWriteBlock(vol, nSect, buf);
return rc;
}
/*
* adfWriteLSEGblock
*
*/
RETCODE
adfWriteLSEGblock(struct Device *dev, int32_t nSect, struct bLSEGblock* lseg)
{
uint8_t buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
struct nativeFunctions *nFct;
RETCODE rc;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWriteLSEGblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(lseg->id,"LSEG",4);
lseg->size = sizeof(struct bLSEGblock)/sizeof(int32_t);
memcpy(buf, lseg, sizeof(struct bLSEGblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_LSEG);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8,newSum);
/* *(int32_t*)(buf+8) = swapLong((uint8_t*)&newSum);*/
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc=(*nFct->adfNativeWriteSector)(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
else
rc=adfWriteDumpSector(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
if (rc!=RC_OK)
return RC_ERROR;
return RC_OK;
}
/*
* adfWriteDirCblock
*
*/
RETCODE adfWriteDirCBlock(struct Volume* vol, int32_t nSect, struct bDirCacheBlock* dirc)
{
unsigned char buf[LOGICAL_BLOCK_SIZE];
uint32_t newSum;
dirc->type = T_DIRC;
dirc->headerKey = nSect;
memcpy(buf, dirc, LOGICAL_BLOCK_SIZE);
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_CACHE);
#endif
newSum = adfNormalSum(buf, 20, LOGICAL_BLOCK_SIZE);
swLong(buf+20,newSum);
/* *(int32_t*)(buf+20) = swapLong((unsigned char*)&newSum);*/
if (adfWriteBlock(vol, nSect, buf)!=RC_OK)
return RC_ERROR;
/*puts("adfWriteDirCBlock");*/
return RC_OK;
}
/*
* adfWriteFileExtBlock
*
*/
RETCODE adfWriteFileExtBlock(struct Volume *vol, SECTNUM nSect, struct bFileExtBlock* fext)
{
unsigned char buf[512];
uint32_t newSum;
RETCODE rc = RC_OK;
fext->type = T_LIST;
fext->secType = ST_FILE;
fext->dataSize = 0L;
fext->firstData = 0L;
memcpy(buf,fext,512);
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_FEXT);
#endif
newSum = adfNormalSum(buf,20,512);
swLong(buf+20,newSum);
/* *(int32_t*)(buf+20) = swapLong((unsigned char*)&newSum);*/
adfWriteBlock(vol,nSect,buf);
return rc;
}
/*
* adfWriteFSHDblock
*
*/
RETCODE
adfWriteFSHDblock(struct Device *dev, long nSect, struct bFSHDblock* fshd)
{
unsigned char buf[LOGICAL_BLOCK_SIZE];
unsigned long newSum;
struct nativeFunctions *nFct;
RETCODE rc = RC_OK;
if (dev->readOnly) {
(*adfEnv.wFct)("adfWriteFSHDblock : can't write block, read only device");
return RC_ERROR;
}
memset(buf,0,LOGICAL_BLOCK_SIZE);
strncpy(fshd->id,"FSHD",4);
fshd->size = sizeof(struct bFSHDblock)/sizeof(long);
memcpy(buf, fshd, sizeof(struct bFSHDblock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_FSHD);
#endif
newSum = adfNormalSum(buf, 8, LOGICAL_BLOCK_SIZE);
swLong(buf+8, newSum);
/* *(long*)(buf+8) = swapLong((unsigned char*)&newSum);*/
nFct = adfEnv.nativeFct;
if (dev->isNativeDev)
rc=(*nFct->adfNativeWriteSector)(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
else
rc=adfWriteDumpSector(dev, nSect, LOGICAL_BLOCK_SIZE, buf);
if (rc!=RC_OK)
return RC_ERROR;
return RC_OK;
}
/*
* adfWriteDirBlock
*
*/
RETCODE adfWriteDirBlock(struct Volume* vol, SECTNUM nSect, struct bDirBlock *dir)
{
unsigned char buf[512];
uint32_t newSum;
/*printf("wdirblk=%d\n",nSect);*/
dir->type = T_HEADER;
dir->highSeq = 0;
dir->hashTableSize = 0;
dir->secType = ST_DIR;
memcpy(buf, dir, sizeof(struct bDirBlock));
#ifdef LITT_ENDIAN
swapEndian(buf, SWBL_DIR);
#endif
newSum = adfNormalSum(buf,20,sizeof(struct bDirBlock));
swLong(buf+20, newSum);
if (adfWriteBlock(vol, nSect, buf)!=RC_OK)
return RC_ERROR;
return RC_OK;
}