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