tools/adflib/adf_file.c

   1 /*
   2  *  ADF Library. (C) 1997-1999 Laurent Clevy
   3  *
   4  *  adf_file.c
   5  *
   6  *  file code
   7  */
   8
   9 #include <stdio.h>
  10 #include <stdlib.h>
  11 #include <string.h>
  12
  13 #include "adf_util.h"
  14 #include "adf_file.h"
  15 #include "adf_str.h"
  16 #include "defendian.h"
  17 #include "adf_raw.h"
  18 #include "adf_disk.h"
  19 #include "adf_dir.h"
  20 #include "adf_bitm.h"
  21 #include "adf_cache.h"
  22
  23 extern struct Env adfEnv;
  24
  25 void adfFileTruncate(struct Volume *vol, SECTNUM nParent, char *name)
  26 {
  27
  28 }
  29
  30
  31 /*
  32  * adfFileFlush
  33  *
  34  */
  35 void adfFlushFile(struct File *file)
  36 {
  37     struct bEntryBlock parent;
  38     struct bOFSDataBlock *data;
  39
  40     if (file->currentExt) {
  41         if (file->writeMode)
  42             adfWriteFileExtBlock(file->volume, file->currentExt->headerKey,
  43                 file->currentExt);
  44     }
  45     if (file->currentData) {
  46         if (file->writeMode) {
  47             file->fileHdr->byteSize = file->pos;
  48                 if (isOFS(file->volume->dosType)) {
  49                 data = (struct bOFSDataBlock *)file->currentData;
  50                 data->dataSize = file->posInDataBlk;
  51             }
  52             if (file->fileHdr->byteSize>0)
  53                 adfWriteDataBlock(file->volume, file->curDataPtr,
  54                                     file->currentData);
  55         }
  56     }
  57     if (file->writeMode) {
  58         file->fileHdr->byteSize = file->pos;
  59 //printf("pos=%ld\n",file->pos);
  60         adfTime2AmigaTime(adfGiveCurrentTime(),
  61             &(file->fileHdr->days),&(file->fileHdr->mins),&(file->fileHdr->ticks) );
  62         adfWriteFileHdrBlock(file->volume, file->fileHdr->headerKey, file->fileHdr);
  63
  64             if (isDIRCACHE(file->volume->dosType)) {
  65 //printf("parent=%ld\n",file->fileHdr->parent);
  66             adfReadEntryBlock(file->volume, file->fileHdr->parent, &parent);
  67             adfUpdateCache(file->volume, &parent, (struct bEntryBlock*)file->fileHdr,FALSE);
  68         }
  69         adfUpdateBitmap(file->volume);
  70     }
  71 }
  72
  73
  74 /*
  75  * adfGetFileBlocks
  76  *
  77  */
  78 RETCODE adfGetFileBlocks(struct Volume* vol, struct bFileHeaderBlock* entry,
  79     struct FileBlocks* fileBlocks)
  80 {
  81     ULONG n, m;
  82     SECTNUM nSect;
  83     struct bFileExtBlock extBlock;
  84     ULONG i;
  85
  86     fileBlocks->header = entry->headerKey;
  87     adfFileRealSize( entry->byteSize, vol->datablockSize,
  88         &(fileBlocks->nbData), &(fileBlocks->nbExtens) );
  89
  90     fileBlocks->data=(SECTNUM*)malloc(fileBlocks->nbData * sizeof(SECTNUM));
  91     if (!fileBlocks->data) {
  92         (*adfEnv.eFct)("adfGetFileBlocks : malloc");
  93         return RC_MALLOC;
  94     }
  95
  96     fileBlocks->extens=(SECTNUM*)malloc(fileBlocks->nbExtens * sizeof(SECTNUM));
  97     if (!fileBlocks->extens) {
  98         (*adfEnv.eFct)("adfGetFileBlocks : malloc");
  99         return RC_MALLOC;
 100     }
 101
 102     n = m = 0;
 103     /* in file header block */
 104     for(i=0; i<entry->highSeq; i++)
 105         fileBlocks->data[n++] = entry->dataBlocks[MAX_DATABLK-1-i];
 106
 107     /* in file extension blocks */
 108     nSect = entry->extension;
 109     while(nSect!=0) {
 110         fileBlocks->extens[m++] = nSect;
 111         adfReadFileExtBlock(vol, nSect, &extBlock);
 112         for(i=0; i<extBlock.highSeq; i++)
 113             fileBlocks->data[n++] = extBlock.dataBlocks[MAX_DATABLK-1-i];
 114         nSect = extBlock.extension;
 115     }
 116     if ( (fileBlocks->nbExtens+fileBlocks->nbData) != (n+m) )
 117         (*adfEnv.wFct)("adfGetFileBlocks : less blocks than expected");
 118
 119     return RC_OK;
 120 }
 121
 122 /*
 123  * adfFreeFileBlocks
 124  *
 125  */
 126 RETCODE adfFreeFileBlocks(struct Volume* vol, struct bFileHeaderBlock *entry)
 127 {
 128     int i;
 129     struct FileBlocks fileBlocks;
 130     RETCODE rc = RC_OK;
 131
 132     adfGetFileBlocks(vol,entry,&fileBlocks);
 133
 134     for(i=0; i<fileBlocks.nbData; i++) {
 135         adfSetBlockFree(vol, fileBlocks.data[i]);
 136     }
 137     for(i=0; i<fileBlocks.nbExtens; i++) {
 138         adfSetBlockFree(vol, fileBlocks.extens[i]);
 139     }
 140
 141     free(fileBlocks.data);
 142     free(fileBlocks.extens);
 143
 144     return rc;
 145 }
 146
 147
 148 /*
 149  * adfFileRealSize
 150  *
 151  * Compute and return real number of block used by one file
 152  * Compute number of datablocks and file extension blocks
 153  *
 154  */
 155 ULONG adfFileRealSize(ULONG size, int blockSize, ULONG *dataN, ULONG *extN)
 156 {
 157     ULONG data, ext;
 158
 159    /*--- number of data blocks ---*/
 160     data = size / blockSize;
 161     if ( size % blockSize )
 162         data++;
 163
 164     /*--- number of header extension blocks ---*/
 165     ext = 0;
 166     if (data>MAX_DATABLK) {
 167         ext = (data-MAX_DATABLK) / MAX_DATABLK;
 168         if ( (data-MAX_DATABLK) % MAX_DATABLK )
 169             ext++;
 170     }
 171
 172     if (dataN)
 173         *dataN = data;
 174     if (extN)
 175         *extN = ext;
 176
 177     return(ext+data+1);
 178 }
 179
 180
 181 /*
 182  * adfWriteFileHdrBlock
 183  *
 184  */
 185 RETCODE adfWriteFileHdrBlock(struct Volume *vol, SECTNUM nSect, struct bFileHeaderBlock* fhdr)
 186 {
 187     unsigned char buf[512];
 188     ULONG newSum;
 189     RETCODE rc = RC_OK;
 190 //printf("adfWriteFileHdrBlock %ld\n",nSect);
 191     fhdr->type = T_HEADER;
 192     fhdr->dataSize = 0;
 193     fhdr->secType = ST_FILE;
 194
 195     memcpy(buf, fhdr, sizeof(struct bFileHeaderBlock));
 196 #ifdef LITT_ENDIAN
 197     swapEndian(buf, SWBL_FILE);
 198 #endif
 199     newSum = adfNormalSum(buf,20,sizeof(struct bFileHeaderBlock));
 200     swLong(buf+20, newSum);
 201 //    *(ULONG*)(buf+20) = swapLong((unsigned char*)&newSum);
 202
 203     adfWriteBlock(vol, nSect, buf);
 204
 205     return rc;
 206 }
 207
 208
 209 /*
 210  * adfFileSeek
 211  *
 212  */
 213 void adfFileSeek(struct File *file, ULONG pos)
 214 {
 215     SECTNUM extBlock, nSect;
 216     ULONG nPos;
 217     int i;
 218
 219     nPos = min(pos, file->fileHdr->byteSize);
 220     file->pos = nPos;
 221     extBlock = adfPos2DataBlock(nPos, file->volume->datablockSize,
 222         &(file->posInExtBlk), &(file->posInDataBlk), &(file->curDataPtr) );
 223     if (extBlock==-1) {
 224         adfReadDataBlock(file->volume,
 225             file->fileHdr->dataBlocks[MAX_DATABLK-1-file->curDataPtr],
 226             file->currentData);
 227     }
 228     else {
 229         nSect = file->fileHdr->extension;
 230         i = 0;
 231         while( i<extBlock && nSect!=0 ) {
 232             adfReadFileExtBlock(file->volume, nSect, file->currentExt );
 233             nSect = file->currentExt->extension;
 234         }
 235         if (i!=extBlock)
 236             (*adfEnv.wFct)("error");
 237         adfReadDataBlock(file->volume,
 238             file->currentExt->dataBlocks[file->posInExtBlk], file->currentData);
 239     }
 240 }
 241
 242
 243 /*
 244  * adfFileOpen
 245  *
 246  */
 247 struct File* adfOpenFile(struct Volume *vol, char* name, char *mode)
 248 {
 249     struct File *file;
 250     SECTNUM nSect;
 251     struct bEntryBlock entry, parent;
 252     BOOL write;
 253     char filename[200];
 254
 255     write=( strcmp("w",mode)==0 || strcmp("a",mode)==0 );
 256
 257         if (write && vol->dev->readOnly) {
 258         (*adfEnv.wFct)("adfFileOpen : device is mounted 'read only'");
 259         return NULL;
 260     }
 261
 262     adfReadEntryBlock(vol, vol->curDirPtr, &parent);
 263
 264     nSect = adfNameToEntryBlk(vol, parent.hashTable, name, &entry, NULL);
 265     if (!write && nSect==-1) {
 266         sprintf(filename,"adfFileOpen : file \"%s\" not found.",name);
 267         (*adfEnv.wFct)(filename);
 268 //fprintf(stdout,"filename %s %d, parent =%d\n",name,strlen(name),vol->curDirPtr);
 269                  return NULL;
 270     }
 271     if (!write && hasR(entry.access)) {
 272         (*adfEnv.wFct)("adfFileOpen : access denied"); return NULL; }
 273 /*    if (entry.secType!=ST_FILE) {
 274         (*adfEnv.wFct)("adfFileOpen : not a file"); return NULL; }
 275         if (write && (hasE(entry.access)||hasW(entry.access))) {
 276         (*adfEnv.wFct)("adfFileOpen : access denied"); return NULL; }
 277 */    if (write && nSect!=-1) {
 278         (*adfEnv.wFct)("adfFileOpen : file already exists"); return NULL; }
 279
 280     file = (struct File*)malloc(sizeof(struct File));
 281     if (!file) { (*adfEnv.wFct)("adfFileOpen : malloc"); return NULL; }
 282     file->fileHdr = (struct bFileHeaderBlock*)malloc(sizeof(struct bFileHeaderBlock));
 283     if (!file->fileHdr) {
 284                 (*adfEnv.wFct)("adfFileOpen : malloc");
 285                 free(file); return NULL;
 286     }
 287     file->currentData = malloc(512*sizeof(unsigned char));
 288     if (!file->currentData) {
 289                 (*adfEnv.wFct)("adfFileOpen : malloc");
 290         free(file->fileHdr); free(file); return NULL;
 291     }
 292
 293     memset(file->currentData, 0xff, 512);
 294
 295     file->volume = vol;
 296     file->pos = 0;
 297     file->posInExtBlk = 0;
 298     file->posInDataBlk = 0;
 299     file->writeMode = write;
 300     file->currentExt = NULL;
 301     file->nDataBlock = 0;
 302
 303     if (strcmp("w",mode)==0) {
 304         memset(file->fileHdr,0,512);
 305         adfCreateFile(vol,vol->curDirPtr,name,file->fileHdr);
 306         file->eof = TRUE;
 307     }
 308     else if (strcmp("a",mode)==0) {
 309         memcpy(file->fileHdr,&entry,sizeof(struct bFileHeaderBlock));
 310         file->eof = TRUE;
 311         adfFileSeek(file, file->fileHdr->byteSize);
 312     }
 313     else if (strcmp("r",mode)==0) {
 314         memcpy(file->fileHdr,&entry,sizeof(struct bFileHeaderBlock));
 315         file->eof = FALSE;
 316     }
 317
 318 //puts("adfOpenFile");
 319     return(file);
 320 }
 321
 322
 323 /*
 324  * adfCloseFile
 325  *
 326  */
 327 void adfCloseFile(struct File *file)
 328 {
 329
 330     if (file==0)
 331         return;
 332 //puts("adfCloseFile in");
 333
 334     adfFlushFile(file);
 335
 336     if (file->currentExt)
 337         free(file->currentExt);
 338
 339     if (file->currentData)
 340         free(file->currentData);
 341
 342     free(file->fileHdr);
 343     free(file);
 344
 345 //puts("adfCloseFile out");
 346 }
 347
 348
 349 /*
 350  * adfReadFile
 351  *
 352  */
 353 ULONG adfReadFile(struct File* file, ULONG n, unsigned char *buffer)
 354 {
 355     ULONG bytesRead;
 356     unsigned char *dataPtr, *bufPtr;
 357         int blockSize, size;
 358
 359     if (n==0) return(n);
 360     blockSize = file->volume->datablockSize;
 361 /*puts("adfReadFile");*/
 362     if (file->pos+n > file->fileHdr->byteSize)
 363         n = file->fileHdr->byteSize - file->pos;
 364
 365     if (isOFS(file->volume->dosType))
 366         dataPtr = (unsigned char*)(file->currentData)+24;
 367     else
 368         dataPtr = file->currentData;
 369
 370     if (file->pos==0 || file->posInDataBlk==blockSize) {
 371         adfReadNextFileBlock(file);
 372         file->posInDataBlk = 0;
 373     }
 374
 375     bytesRead = 0; bufPtr = buffer;
 376     size = 0;
 377     while ( bytesRead < n ) {
 378         size = min(n-bytesRead, blockSize-file->posInDataBlk);
 379         memcpy(bufPtr, dataPtr+file->posInDataBlk, size);
 380         bufPtr += size;
 381         file->pos += size;
 382         bytesRead += size;
 383         file->posInDataBlk += size;
 384         if (file->posInDataBlk==blockSize && bytesRead<n) {
 385             adfReadNextFileBlock(file);
 386             file->posInDataBlk = 0;
 387         }
 388     }
 389     file->eof = (file->pos==file->fileHdr->byteSize);
 390     return( bytesRead );
 391 }
 392
 393
 394 /*
 395  * adfEndOfFile
 396  *
 397  */
 398 BOOL adfEndOfFile(struct File* file)
 399 {
 400     return(file->eof);
 401 }
 402
 403
 404 /*
 405  * adfReadNextFileBlock
 406  *
 407  */
 408 RETCODE adfReadNextFileBlock(struct File* file)
 409 {
 410     SECTNUM nSect;
 411     struct bOFSDataBlock *data;
 412     RETCODE rc = RC_OK;
 413
 414     data =(struct bOFSDataBlock *) file->currentData;
 415
 416     if (file->nDataBlock==0) {
 417         nSect = file->fileHdr->firstData;
 418     }
 419     else if (isOFS(file->volume->dosType)) {
 420         nSect = data->nextData;
 421     }
 422     else {
 423         if (file->nDataBlock<MAX_DATABLK)
 424             nSect = file->fileHdr->dataBlocks[MAX_DATABLK-1-file->nDataBlock];
 425         else {
 426             if (file->nDataBlock==MAX_DATABLK) {
 427                 file->currentExt=(struct bFileExtBlock*)malloc(sizeof(struct bFileExtBlock));
 428                 if (!file->currentExt) (*adfEnv.eFct)("adfReadNextFileBlock : malloc");
 429                 adfReadFileExtBlock(file->volume, file->fileHdr->extension,
 430                     file->currentExt);
 431                 file->posInExtBlk = 0;
 432             }
 433             else if (file->posInExtBlk==MAX_DATABLK) {
 434                 adfReadFileExtBlock(file->volume, file->currentExt->extension,
 435                     file->currentExt);
 436                 file->posInExtBlk = 0;
 437             }
 438             nSect = file->currentExt->dataBlocks[MAX_DATABLK-1-file->posInExtBlk];
 439             file->posInExtBlk++;
 440         }
 441     }
 442     adfReadDataBlock(file->volume,nSect,file->currentData);
 443
 444     if (isOFS(file->volume->dosType) && data->seqNum!=file->nDataBlock+1)
 445         (*adfEnv.wFct)("adfReadNextFileBlock : seqnum incorrect");
 446
 447     file->nDataBlock++;
 448
 449     return rc;
 450 }
 451
 452
 453 /*
 454  * adfWriteFile
 455  *
 456  */
 457 ULONG adfWriteFile(struct File *file, ULONG n, unsigned char *buffer)
 458 {
 459     ULONG bytesWritten;
 460     unsigned char *dataPtr, *bufPtr;
 461     int size, blockSize;
 462     struct bOFSDataBlock *dataB;
 463
 464     if (n==0) return (n);
 465 //puts("adfWriteFile");
 466     blockSize = file->volume->datablockSize;
 467     if (isOFS(file->volume->dosType)) {
 468         dataB =(struct bOFSDataBlock *)file->currentData;
 469         dataPtr = dataB->data;
 470     }
 471     else
 472         dataPtr = file->currentData;
 473
 474     if (file->pos==0 || file->posInDataBlk==blockSize) {
 475         if (adfCreateNextFileBlock(file)==-1)
 476             (*adfEnv.wFct)("adfWritefile : no more free sector availbale");
 477         file->posInDataBlk = 0;
 478     }
 479
 480     bytesWritten = 0; bufPtr = buffer;
 481     while( bytesWritten<n ) {
 482         size = min(n-bytesWritten, blockSize-file->posInDataBlk);
 483         memcpy(dataPtr+file->posInDataBlk, bufPtr, size);
 484         bufPtr += size;
 485         file->pos += size;
 486         bytesWritten += size;
 487         file->posInDataBlk += size;
 488         if (file->posInDataBlk==blockSize && bytesWritten<n) {
 489             if (adfCreateNextFileBlock(file)==-1)
 490                 (*adfEnv.wFct)("adfWritefile : no more free sector availbale");
 491             file->posInDataBlk = 0;
 492         }
 493     }
 494     return( bytesWritten );
 495 }
 496
 497
 498 /*
 499  * adfCreateNextFileBlock
 500  *
 501  */
 502 SECTNUM adfCreateNextFileBlock(struct File* file)
 503 {
 504     SECTNUM nSect, extSect;
 505     struct bOFSDataBlock *data;
 506         unsigned int blockSize;
 507     int i;
 508 //puts("adfCreateNextFileBlock");
 509     blockSize = file->volume->datablockSize;
 510     data = file->currentData;
 511
 512     /* the first data blocks pointers are inside the file header block */
 513     if (file->nDataBlock<MAX_DATABLK) {
 514         nSect = adfGet1FreeBlock(file->volume);
 515         if (nSect==-1) return -1;
 516 //printf("adfCreateNextFileBlock fhdr %ld\n",nSect);
 517         if (file->nDataBlock==0)
 518             file->fileHdr->firstData = nSect;
 519         file->fileHdr->dataBlocks[MAX_DATABLK-1-file->nDataBlock] = nSect;
 520         file->fileHdr->highSeq++;
 521     }
 522     else {
 523         /* one more sector is needed for one file extension block */
 524         if ((file->nDataBlock%MAX_DATABLK)==0) {
 525             extSect = adfGet1FreeBlock(file->volume);
 526 //printf("extSect=%ld\n",extSect);
 527             if (extSect==-1) return -1;
 528
 529             /* the future block is the first file extension block */
 530             if (file->nDataBlock==MAX_DATABLK) {
 531                 file->currentExt=(struct bFileExtBlock*)malloc(sizeof(struct bFileExtBlock));
 532                 if (!file->currentExt) {
 533                     adfSetBlockFree(file->volume, extSect);
 534                     (*adfEnv.eFct)("adfCreateNextFileBlock : malloc");
 535                     return -1;
 536                 }
 537                 file->fileHdr->extension = extSect;
 538             }
 539
 540             /* not the first : save the current one, and link it with the future */
 541             if (file->nDataBlock>=2*MAX_DATABLK) {
 542                 file->currentExt->extension = extSect;
 543 //printf ("write ext=%d\n",file->currentExt->headerKey);
 544                 adfWriteFileExtBlock(file->volume, file->currentExt->headerKey,
 545                     file->currentExt);
 546             }
 547
 548             /* initializes a file extension block */
 549             for(i=0; i<MAX_DATABLK; i++)
 550                 file->currentExt->dataBlocks[i] = 0L;
 551             file->currentExt->headerKey = extSect;
 552             file->currentExt->parent = file->fileHdr->headerKey;
 553             file->currentExt->highSeq = 0L;
 554             file->currentExt->extension = 0L;
 555             file->posInExtBlk = 0L;
 556 //printf("extSect=%ld\n",extSect);
 557         }
 558         nSect = adfGet1FreeBlock(file->volume);
 559         if (nSect==-1)
 560             return -1;
 561
 562 //printf("adfCreateNextFileBlock ext %ld\n",nSect);
 563
 564         file->currentExt->dataBlocks[MAX_DATABLK-1-file->posInExtBlk] = nSect;
 565         file->currentExt->highSeq++;
 566         file->posInExtBlk++;
 567     }
 568
 569     /* builds OFS header */
 570     if (isOFS(file->volume->dosType)) {
 571         /* writes previous data block and link it  */
 572         if (file->pos>=blockSize) {
 573             data->nextData = nSect;
 574             adfWriteDataBlock(file->volume, file->curDataPtr, file->currentData);
 575 //printf ("writedata=%d\n",file->curDataPtr);
 576         }
 577         /* initialize a new data block */
 578         for(i=0; i<(int)blockSize; i++)
 579             data->data[i]=~0;
 580         data->seqNum = file->nDataBlock+1;
 581         data->dataSize = blockSize;
 582         data->nextData = 0L;
 583         data->headerKey = file->fileHdr->headerKey;
 584     }
 585     else
 586         if (file->pos>=blockSize) {
 587             adfWriteDataBlock(file->volume, file->curDataPtr, file->currentData);
 588 //printf ("writedata=%d\n",file->curDataPtr);
 589             memset(file->currentData,0xff,512);
 590         }
 591
 592 //printf("datablk=%d\n",nSect);
 593     file->curDataPtr = nSect;
 594     file->nDataBlock++;
 595
 596     return(nSect);
 597 }
 598
 599
 600 /*
 601  * adfPos2DataBlock
 602  *
 603  */
 604 ULONG adfPos2DataBlock(ULONG pos, int blockSize,
 605     int *posInExtBlk, int *posInDataBlk, ULONG *curDataN )
 606 {
 607     ULONG extBlock;
 608
 609     *posInDataBlk = pos%blockSize;
 610     *curDataN = pos/blockSize;
 611     if (*posInDataBlk==0)
 612         (*curDataN)++;
 613     if (*curDataN<72) {
 614         *posInExtBlk = 0;
 615         return -1;
 616     }
 617     else {
 618         *posInExtBlk = (pos-72*blockSize)%blockSize;
 619         extBlock = (pos-72*blockSize)/blockSize;
 620         if (*posInExtBlk==0)
 621             extBlock++;
 622         return extBlock;
 623     }
 624 }
 625
 626
 627 /*
 628  * adfReadDataBlock
 629  *
 630  */
 631 RETCODE adfReadDataBlock(struct Volume *vol, SECTNUM nSect, void *data)
 632 {
 633     unsigned char buf[512];
 634     struct bOFSDataBlock *dBlock;
 635     RETCODE rc = RC_OK;
 636
 637     adfReadBlock(vol, nSect,buf);
 638
 639     memcpy(data,buf,512);
 640
 641     if (isOFS(vol->dosType)) {
 642 #ifdef LITT_ENDIAN
 643         swapEndian(data, SWBL_DATA);
 644 #endif
 645         dBlock = (struct bOFSDataBlock*)data;
 646 //printf("adfReadDataBlock %ld\n",nSect);
 647
 648         if (dBlock->checkSum!=adfNormalSum(buf,20,sizeof(struct bOFSDataBlock)))
 649             (*adfEnv.wFct)("adfReadDataBlock : invalid checksum");
 650         if (dBlock->type!=T_DATA)
 651             (*adfEnv.wFct)("adfReadDataBlock : id T_DATA not found");
 652         if (dBlock->dataSize>488)
 653             (*adfEnv.wFct)("adfReadDataBlock : dataSize incorrect");
 654         if ( !isSectNumValid(vol,dBlock->headerKey) )
 655                         (*adfEnv.wFct)("adfReadDataBlock : headerKey out of range");
 656         if ( !isSectNumValid(vol,dBlock->nextData) )
 657                         (*adfEnv.wFct)("adfReadDataBlock : nextData out of range");
 658     }
 659
 660     return rc;
 661 }
 662
 663
 664 /*
 665  * adfWriteDataBlock
 666  *
 667  */
 668 RETCODE adfWriteDataBlock(struct Volume *vol, SECTNUM nSect, void *data)
 669 {
 670     unsigned char buf[512];
 671     ULONG newSum;
 672     struct bOFSDataBlock *dataB;
 673     RETCODE rc = RC_OK;
 674
 675     newSum = 0L;
 676     if (isOFS(vol->dosType)) {
 677         dataB = (struct bOFSDataBlock *)data;
 678         dataB->type = T_DATA;
 679         memcpy(buf,dataB,512);
 680 #ifdef LITT_ENDIAN
 681         swapEndian(buf, SWBL_DATA);
 682 #endif
 683         newSum = adfNormalSum(buf,20,512);
 684         swLong(buf+20,newSum);
 685 //        *(ULONG*)(buf+20) = swapLong((unsigned char*)&newSum);
 686         adfWriteBlock(vol,nSect,buf);
 687     }
 688     else {
 689         adfWriteBlock(vol,nSect,data);
 690     }
 691 //printf("adfWriteDataBlock %ld\n",nSect);
 692
 693     return rc;
 694 }
 695
 696
 697 /*
 698  * adfReadFileExtBlock
 699  *
 700  */
 701 RETCODE adfReadFileExtBlock(struct Volume *vol, SECTNUM nSect, struct bFileExtBlock* fext)
 702 {
 703     unsigned char buf[sizeof(struct bFileExtBlock)];
 704     RETCODE rc = RC_OK;
 705
 706     adfReadBlock(vol, nSect,buf);
 707 /*printf("read fext=%d\n",nSect);*/
 708     memcpy(fext,buf,sizeof(struct bFileExtBlock));
 709 #ifdef LITT_ENDIAN
 710     swapEndian((unsigned char*)fext, SWBL_FEXT);
 711 #endif
 712     if (fext->checkSum!=adfNormalSum(buf,20,sizeof(struct bFileExtBlock)))
 713         (*adfEnv.wFct)("adfReadFileExtBlock : invalid checksum");
 714     if (fext->type!=T_LIST)
 715         (*adfEnv.wFct)("adfReadFileExtBlock : type T_LIST not found");
 716     if (fext->secType!=ST_FILE)
 717         (*adfEnv.wFct)("adfReadFileExtBlock : stype  ST_FILE not found");
 718     if (fext->headerKey!=nSect)
 719         (*adfEnv.wFct)("adfReadFileExtBlock : headerKey!=nSect");
 720     if (fext->highSeq>MAX_DATABLK)
 721         (*adfEnv.wFct)("adfReadFileExtBlock : highSeq out of range");
 722     if ( !isSectNumValid(vol, fext->parent) )
 723         (*adfEnv.wFct)("adfReadFileExtBlock : parent out of range");
 724     if ( fext->extension!=0 && !isSectNumValid(vol, fext->extension) )
 725         (*adfEnv.wFct)("adfReadFileExtBlock : extension out of range");
 726
 727     return rc;
 728 }
 729
 730
 731 /*
 732  * adfWriteFileExtBlock
 733  *
 734  */
 735 RETCODE adfWriteFileExtBlock(struct Volume *vol, SECTNUM nSect, struct bFileExtBlock* fext)
 736 {
 737     unsigned char buf[512];
 738     ULONG newSum;
 739     RETCODE rc = RC_OK;
 740
 741     fext->type = T_LIST;
 742     fext->secType = ST_FILE;
 743     fext->dataSize = 0L;
 744     fext->firstData = 0L;
 745
 746     memcpy(buf,fext,512);
 747 #ifdef LITT_ENDIAN
 748     swapEndian(buf, SWBL_FEXT);
 749 #endif
 750     newSum = adfNormalSum(buf,20,512);
 751     swLong(buf+20,newSum);
 752 //    *(ULONG*)(buf+20) = swapLong((unsigned char*)&newSum);
 753
 754     adfWriteBlock(vol,nSect,buf);
 755
 756     return rc;
 757 }
 758 /*###########################################################################*/