rom/filesys/afs/filehandles1.c

   1 /*
   2     Copyright © 1995-2015, The AROS Development Team. All rights reserved.
   3     $Id$
   4 */
   5
   6 #undef DEBUG
   7 #define DEBUG 0
   8
   9 #include "os.h"
  10 #include "filehandles1.h"
  11 #include "filehandles2.h"
  12 #include "hashing.h"
  13 #include "extstrings.h"
  14 #include "checksums.h"
  15 #include "bitmap.h"
  16 #include "error.h"
  17 #include "afsblocks.h"
  18 #include "baseredef.h"
  19 #include "validator.h"
  20
  21 /***********************************************
  22  Name  : getHeaderBlock
  23  Descr.: search through blocks until header block found
  24  Input : name        - object we are searching for
  25          blockbuffer - dirblock we are searching in
  26          block       - will be filled with the block number
  27                        prior to the entry we are using
  28  Output: cache block of last object
  29  See   : locateObject, setDate, setComment, deleteObject
  30 ************************************************/
  31 struct BlockCache *getHeaderBlock
  32         (
  33                 struct AFSBase *afsbase,
  34                 struct Volume *volume,
  35                 CONST_STRPTR name,
  36                 struct BlockCache *blockbuffer,
  37                 ULONG *block,
  38                 SIPTR *error
  39         )
  40 {
  41 ULONG key;
  42
  43         D(bug("[afs]    getHeaderBlock: searching for block of '%s'\n",name));
  44         key = getHashKey(name,volume->SizeBlock-56,volume->dosflags)+BLK_TABLE_START;
  45         *block = blockbuffer->blocknum;
  46         if (blockbuffer->buffer[key] == 0)
  47         {
  48                 *error = ERROR_OBJECT_NOT_FOUND;
  49                 return NULL;
  50         }
  51         blockbuffer=getBlock(afsbase, volume,OS_BE2LONG(blockbuffer->buffer[key]));
  52         if (blockbuffer == NULL)
  53         {
  54                 *error = ERROR_UNKNOWN;
  55                 return NULL;
  56         }
  57 D
  58 (
  59         {
  60                 char *name;
  61                 name = (char *)blockbuffer->buffer+(BLK_DIRECTORYNAME_START(volume)*4);
  62                 kprintf("[afs] %.*s\n", name[0], name+1);
  63         }
  64 );
  65         if (calcChkSum(volume->SizeBlock, blockbuffer->buffer) != 0)
  66         {
  67                 /*
  68                  * since we will not work on blockbuffer here any more,
  69                  * we don't have to preserve it.
  70                  */
  71                 if (showError(afsbase, ERR_CHECKSUM, blockbuffer->blocknum))
  72          launchValidator(afsbase, volume);
  73
  74                 *error = ERROR_UNKNOWN;
  75                 return NULL;
  76         }
  77         if (OS_BE2LONG(blockbuffer->buffer[BLK_PRIMARY_TYPE]) != T_SHORT)
  78         {
  79                 /*
  80                  * again, we don't work on blockbuffer any more
  81                  * no need to preserve BlockCache structure.
  82                  */
  83                 if (showError(afsbase, ERR_BLOCKTYPE, blockbuffer->blocknum))
  84                         launchValidator(afsbase, volume);
  85
  86                 *error = ERROR_OBJECT_WRONG_TYPE;
  87                 return NULL;
  88         }
  89
  90         while (!noCaseStrCmp(name, (char *)blockbuffer->buffer + (BLK_DIRECTORYNAME_START(volume)*4),
  91                              volume->dosflags, MAX_NAME_LENGTH))
  92         {
  93                 *block = blockbuffer->blocknum;
  94                 if (blockbuffer->buffer[BLK_HASHCHAIN(volume)] == 0)
  95                 {
  96                         *error=ERROR_OBJECT_NOT_FOUND;
  97                         return NULL;
  98                 }
  99                 blockbuffer=getBlock
 100                         (
 101                                 afsbase,
 102                                 volume,
 103                                 OS_BE2LONG(blockbuffer->buffer[BLK_HASHCHAIN(volume)])
 104                         );
 105                 if (blockbuffer == NULL)
 106                 {
 107                         *error = ERROR_UNKNOWN;
 108                         return NULL;
 109                 }
 110                 if (calcChkSum(volume->SizeBlock, blockbuffer->buffer) != 0)
 111                 {
 112                         /*
 113                          * we won't work on blockbuffer any more
 114                          * don't preserve the buffer.
 115                          */
 116                         if (showError(afsbase, ERR_CHECKSUM,blockbuffer->blocknum))
 117                                 launchValidator(afsbase, volume);
 118
 119                         *error=ERROR_UNKNOWN;
 120                         return NULL;
 121                 }
 122                 if (OS_BE2LONG(blockbuffer->buffer[BLK_PRIMARY_TYPE]) != T_SHORT)
 123                 {
 124                         /*
 125                          * not working with blockbuffer :)
 126                          */
 127                         if (showError(afsbase, ERR_BLOCKTYPE, blockbuffer->blocknum))
 128                                 launchValidator(afsbase, volume);
 129
 130                         *error = ERROR_OBJECT_WRONG_TYPE;
 131                         return NULL;
 132                 }
 133         }
 134         return blockbuffer;
 135 }
 136
 137 /*******************************************
 138  Name  : findBlock
 139  Descr.: find the header block of a file/dir
 140  Input : dirah    - directory lock as starting point
 141                    if NULL, start in root dir
 142          name    - path of file/dir
 143          block   - will be filled with the block number
 144                    prior to the entry we are using; rootblock
 145                    if we are searching for the root
 146  Output: NULL=error (evtl. error=ERROR_...)
 147          blockcache structure of found block otherwise
 148 ********************************************/
 149 struct BlockCache *findBlock
 150         (
 151                 struct AFSBase *afsbase,
 152                 struct AfsHandle *dirah,
 153                 CONST_STRPTR name,
 154                 ULONG *block,
 155                 SIPTR *error
 156         )
 157 {
 158 STRPTR pos;
 159 struct BlockCache *blockbuffer;
 160 UBYTE buffer[32];
 161
 162         if (dirah->volume->dostype != 0x444F5300)
 163         {
 164                 D(bug("[afs] Unknown dostype 0x%08x\n", dirah->volume->dostype));
 165                 *error = ERROR_NOT_A_DOS_DISK;
 166                 return 0;
 167         }
 168         *block = dirah->header_block;
 169
 170         D(bug("[afs]    findBlock: startblock=%ld\n",*block));
 171         /* get first entry (root or filelock refers to) */
 172         blockbuffer = getBlock(afsbase, dirah->volume, *block);
 173         if (blockbuffer == NULL)
 174         {
 175                 *error = ERROR_UNKNOWN;
 176                 D(bug("[afs]    error blockbuffer\n"));
 177                 return NULL;
 178         }
 179         if (calcChkSum(dirah->volume->SizeBlock, blockbuffer->buffer) != 0)
 180         {
 181                 /*
 182                  * not working with blockbuffer any more.
 183                  * otherwise we would need to preserve it (BCF_USED or one more time getBlock)
 184                  */
 185                 if (showError(afsbase, ERR_CHECKSUM, *block))
 186                         launchValidator(afsbase, dirah->volume);
 187
 188                 *error = ERROR_UNKNOWN;
 189                 D(bug("[afs]    error checksum\n"));
 190                 return NULL;
 191         }
 192         if (OS_BE2LONG(blockbuffer->buffer[BLK_PRIMARY_TYPE]) != T_SHORT)
 193         {
 194                 /*
 195                  * read above comment
 196                  */
 197                 if (showError(afsbase, ERR_BLOCKTYPE, *block))
 198                         launchValidator(afsbase, dirah->volume);
 199
 200                 *error = ERROR_OBJECT_WRONG_TYPE;
 201                 D(bug("[afs]    error wrong type\n"));
 202                 return NULL;
 203         }
 204         while (*name)
 205         {
 206                 if (*name == '/')       /* get parent entry ? */
 207                 {
 208                         if (blockbuffer->buffer[BLK_PARENT(dirah->volume)] == 0)
 209                         {
 210                                 *error = ERROR_OBJECT_NOT_FOUND;
 211                                 D(bug("[afs]    object not found\n"));
 212                                 return NULL;
 213                         }
 214                         D(bug("[afs]   findBlock: getting parent\n"));
 215                         blockbuffer = getBlock
 216                                 (
 217                                         afsbase,
 218                                         dirah->volume,
 219                                         OS_BE2LONG(blockbuffer->buffer[BLK_PARENT(dirah->volume)])
 220                                 );
 221                         if (blockbuffer == NULL)
 222                         {
 223                                 *error = ERROR_UNKNOWN;
 224                                 D(bug("[afs]    error no blockbuffer\n"));
 225                                 return NULL;
 226                         }
 227                         name++;
 228                 }
 229                 else
 230                 {
 231                         if (
 232                                         (OS_BE2LONG
 233                                                 (
 234                                                         blockbuffer->buffer[BLK_SECONDARY_TYPE(dirah->volume)]
 235                                                 ) != ST_ROOT) &&
 236                                         (OS_BE2LONG
 237                                                 (
 238                                                         blockbuffer->buffer[BLK_SECONDARY_TYPE(dirah->volume)]
 239                                                 ) != ST_USERDIR) &&
 240                                         (OS_BE2LONG
 241                                                 (
 242                                                         blockbuffer->buffer[BLK_SECONDARY_TYPE(dirah->volume)]
 243                                                 ) != ST_LINKDIR))
 244                         {
 245                                 *error = ERROR_OBJECT_WRONG_TYPE;
 246                                 D(bug("[afs]    error wrong type\n"));
 247                                 return NULL;
 248                         }
 249                         pos = buffer;
 250                         while ((*name != 0) && (*name != '/'))
 251                         {
 252                                 *pos++ = *name++;
 253                         }
 254                         if (*name == '/')
 255                                 name++;
 256                         *pos=0;
 257                         D(bug
 258                                 (
 259                                         "[afs]   findBlock: searching for header block of %s\n",
 260                                         buffer
 261                                 ));
 262                         blockbuffer =
 263                                 getHeaderBlock(afsbase, dirah->volume, buffer, blockbuffer, block, error);
 264                         if (blockbuffer == NULL)
 265                                 break;          /* object not found or other error */
 266                 }
 267         }
 268         D(
 269                 if (blockbuffer != NULL)
 270                         bug("[afs]   findBlock: block=%ld\n",blockbuffer->blocknum);
 271                 else
 272                         bug("[afs]   findBlock: error\n");
 273         );
 274         return blockbuffer;
 275 }
 276
 277 /* add handle to locklist */
 278 void addHandle(struct AfsHandle *ah) {
 279
 280         ah->next=ah->volume->locklist;
 281         ah->volume->locklist=ah;
 282 }
 283
 284 /* remove handle from locklist */
 285 void remHandle(struct AFSBase *afsbase, struct AfsHandle *ah) {
 286 struct AfsHandle *old = NULL;
 287
 288         D(bug("[afs 0x%08lX] Removing handle 0x%08lX\n", ah->volume, ah));
 289         if (ah->volume->volumenode == ah->volumenode) {
 290             D(bug("[afs 0x%08lX] Lock's volume is online\n", ah->volume));
 291             if (ah->volume->locklist==ah)
 292                 ah->volume->locklist=ah->next;
 293             else
 294                 old=ah->volume->locklist;
 295         }
 296 #ifdef __AROS__
 297         else {
 298             D(bug("[afs 0x%08lX] Lock's volume is offline\n", ah->volume));
 299             if (BADDR(ah->volumenode->dol_misc.dol_volume.dol_LockList) == ah)
 300                 if (ah->next)
 301                     ah->volumenode->dol_misc.dol_volume.dol_LockList = MKBADDR(ah->next);
 302                 else {
 303                     D(bug("[afs 0x%08lX] Last lock removed, removing VolumeNode\n", ah->volume));
 304                     remDosNode(afsbase, ah->volumenode);
 305                 }
 306             else
 307                 old = BADDR(ah->volumenode->dol_misc.dol_volume.dol_LockList);
 308         }
 309 #endif
 310         while (old)
 311         {
 312             if (old->next==ah)
 313             {
 314                 old->next=ah->next;
 315                 return;
 316             }
 317             old=old->next;
 318         }
 319 }
 320
 321 /* find handle in locklist */
 322 struct AfsHandle *findHandle(struct Volume *volume, ULONG block) {
 323 struct AfsHandle *ah;
 324
 325         ah=volume->locklist;
 326         while (ah)
 327         {
 328                 if (ah->header_block==block)
 329                         return ah;
 330                 ah=ah->next;
 331         }
 332         return NULL;
 333 }
 334
 335 /****************************************
 336  Name  : allocHandle
 337  Descr.: allocate a new handle
 338  Input : volume    -
 339          fileblock - block of the entry
 340          mode      - type of lock
 341          hashtable - ptr to the (hash)table
 342  Output: AfsHandle for success; NULL otherwise
 343 ****************************************/
 344 struct AfsHandle *allocHandle
 345         (
 346                 struct AFSBase *afsbase,
 347                 struct Volume *volume,
 348                 struct BlockCache *fileblock,
 349                 ULONG mode,
 350                 ULONG *hashtable,
 351                 SIPTR *error
 352         )
 353 {
 354 struct AfsHandle *ah;
 355
 356         ah=(struct AfsHandle *)AllocMem
 357                 (sizeof(struct AfsHandle), MEMF_PUBLIC | MEMF_CLEAR);
 358         if (ah != NULL)
 359         {
 360                 ah->header_block = fileblock->blocknum;
 361                 ah->dirpos = fileblock->blocknum;
 362                 ah->mode = mode;
 363                 ah->current.block = fileblock->blocknum;
 364                 ah->current.filekey = BLK_TABLE_END(volume);
 365                 ah->current.byte = 0;
 366                 ah->current.offset = 0;
 367                 ah->filesize = OS_BE2LONG(fileblock->buffer[BLK_BYTE_SIZE(volume)]);
 368                 ah->volume = volume;
 369                 ah->volumenode = volume->volumenode;
 370                 addHandle(ah);
 371         }
 372         else
 373                 *error = ERROR_NO_FREE_STORE;
 374         return ah;
 375 }
 376
 377 /****************************************
 378  Name  : getHandle
 379  Descr.: check if a new handle can be
 380          allocated and allocate one if
 381          possible
 382  Input : volume    -
 383          fileblock - block of the entry
 384          mode      - type of lock
 385  Output: AfsHandle for success; NULL otherwise
 386 ****************************************/
 387 struct AfsHandle *getHandle
 388         (
 389                 struct AFSBase *afsbase,
 390                 struct Volume *volume,
 391                 struct BlockCache *fileblock,
 392                 ULONG mode,
 393                 SIPTR *error
 394         )
 395 {
 396 struct AfsHandle *ah;
 397
 398         D(bug
 399                 (
 400                         "[afs]    getHandle: trying to get handle for block %lu\n",
 401                         fileblock->blocknum)
 402                 );
 403
 404         *error = 0;
 405
 406         ah = findHandle(volume, fileblock->blocknum);
 407         if (ah != NULL)
 408         {
 409                 if (ah->mode == MODE_READWRITE ||
 410                     ah->mode == MODE_NEWFILE)
 411                 {
 412                         *error = ERROR_OBJECT_IN_USE;
 413                         ah = NULL;
 414                 }
 415         }
 416
 417         if (*error == 0)
 418         {
 419                 ah = allocHandle
 420                         (
 421                                 afsbase,
 422                                 volume,
 423                                 fileblock,
 424                                 mode,
 425                                 (ULONG *)((char *)fileblock->buffer+(BLK_TABLE_START*4)),
 426                                 error
 427                         );
 428         }
 429
 430         return ah;
 431 }
 432
 433 /*****************************************
 434  Name  : openf
 435  Descr.: open (lock) a file
 436  Input : dirah    - a handle filename is
 437                     relative to
 438          filename - filename to lock
 439          mode     - lock type
 440  Output: AfsHandle for success; NULL otherwise
 441 ******************************************/
 442 struct AfsHandle *openf
 443         (
 444                 struct AFSBase *afsbase,
 445                 struct AfsHandle *dirah,
 446                 CONST_STRPTR filename,
 447                 ULONG mode,
 448                 SIPTR *error
 449         )
 450 {
 451 struct AfsHandle *ah = NULL;
 452 struct BlockCache *fileblock;
 453 ULONG block;
 454
 455         D(bug("[afs] openf(%ld,%s,0x%8lx)\n",dirah->header_block,filename,mode));
 456         fileblock = findBlock(afsbase, dirah, filename, &block, error);
 457         if (fileblock != NULL)
 458                 ah = getHandle(afsbase, dirah->volume, fileblock, mode, error);
 459         return ah;
 460 }
 461
 462 /*****************************************
 463  Name  : openfile
 464  Descr.: open (lock) a file
 465  Input : dirah      - a handle filename is
 466                       relative to
 467          name   - filename to lock
 468          mode       - MODE_...
 469          protection - bits for new files
 470  Output: AfsHandle for success; NULL otherwise
 471 ******************************************/
 472 struct AfsHandle *openfile
 473         (
 474                 struct AFSBase *afsbase,
 475                 struct AfsHandle *dirah,
 476                 CONST_STRPTR name,
 477                 ULONG mode,
 478                 ULONG protection,
 479                 SIPTR *error
 480         )
 481 {
 482 struct AfsHandle *ah = NULL;
 483 struct BlockCache *fileblock, *dirblock;
 484 UBYTE filename[34];
 485 ULONG block;
 486 ULONG fileblocknum = -1;
 487
 488         /*
 489          * nicely say what's going on
 490          */
 491         D(bug("[afs] openfile(%lu,%s,0x%lx,%lu)\n", dirah->header_block,name,mode,protection));
 492         *error = 0;
 493
 494         /*
 495          * if user wants to delete or create a new file - make sure we can do that.
 496          */
 497         if ((mode != MODE_OLDFILE) && (0 == checkValid(afsbase, dirah->volume)))
 498                 *error = ERROR_DISK_WRITE_PROTECTED;
 499
 500         /*
 501          * get the directory the last component of "name" is in
 502          */
 503         dirblock = getDirBlockBuffer(afsbase, dirah, name, filename, error);
 504
 505         /*
 506          * if no error so far and directory block is found, move on.
 507          */
 508         if (*error == 0 && dirblock != NULL)
 509         {
 510                 /*
 511                  * only if the directory is of DIR or ROOT type
 512                  */
 513                 if ((OS_BE2LONG(dirblock->buffer[BLK_SECONDARY_TYPE(dirah->volume)]) == ST_USERDIR) ||
 514                         (OS_BE2LONG(dirblock->buffer[BLK_SECONDARY_TYPE(dirah->volume)]) == ST_ROOT))
 515                 {
 516                         D(bug("[afs]    parent of %s is on block %lu\n", name, dirblock->blocknum));
 517
 518                         /*
 519                          * get the header block of the file to open
 520                          */
 521                         fileblock = getHeaderBlock(afsbase, dirah->volume, filename, dirblock, &block, error);
 522
 523                         /*
 524                          * check if 'file' is really a FILE
 525                          */
 526                         if ((fileblock != NULL) && (OS_BE2LONG(fileblock->buffer[BLK_SECONDARY_TYPE(dirah->volume)])!=ST_FILE))
 527                         {
 528                                 *error = ERROR_OBJECT_WRONG_TYPE;
 529                         }
 530                         else
 531                         {
 532                                 /*
 533                                  * get file block, if there was (is) a file
 534                                  */
 535                                 if (fileblock != NULL)
 536                                         fileblocknum = fileblock->blocknum;
 537
 538                                 /*
 539                                  * remove existing file if we are asked to clear its contents
 540                                  */
 541                                 if (mode == MODE_NEWFILE)
 542                                         *error = deleteObject(afsbase, dirah, name);
 543
 544                                 /*
 545                                  * if we cleared the file or there was no file at all, move on
 546                                  */
 547                                 if ((*error == 0) || (*error == ERROR_OBJECT_NOT_FOUND))
 548                                 {
 549                                         /*
 550                                          * in case we could not find existing file, or if we deleted this file previously,
 551                                          * create a new one.
 552                                          */
 553                                         if (mode == MODE_NEWFILE)
 554                                         {
 555                                                 /*
 556                                                  * please note that dirblock may become invalid here
 557                                                  */
 558                                                 fileblock = createNewEntry(afsbase, dirah->volume, ST_FILE, filename, dirblock, protection, error);
 559                                         }
 560                                         else
 561                                         {
 562                                                 /*
 563                                                  * we should already have fileblock here
 564                                                  * again, dirblock may become invalid here
 565                                                  */
 566                                                 if (fileblock != NULL)
 567                                                         fileblock = getBlock(afsbase, dirah->volume, fileblocknum);
 568                                         }
 569
 570                                         /*
 571                                          * create a handle for the file
 572                                          */
 573                                         if (fileblock != NULL)
 574                                         {
 575                                                 *error = 0;
 576                                                 ah = getHandle(afsbase, dirah->volume, fileblock, mode, error);
 577                                         }
 578                                 }
 579                         }
 580                 }
 581                 else
 582                         *error = ERROR_OBJECT_WRONG_TYPE;
 583         }
 584         return ah;
 585 }
 586
 587 /***********************************
 588  Name  : closef
 589  Descr.: close a file/free a lock
 590  Input : ah - the handle to close
 591  Output -
 592 ************************************/
 593 void closef(struct AFSBase *afsbase, struct AfsHandle *ah) {
 594
 595         D(bug("[afs] closef(%lu)\n",ah->header_block));
 596         remHandle(afsbase, ah);
 597         FreeMem(ah,sizeof(struct AfsHandle));
 598 }
 599
 600 /******************************************
 601  Name  : readData
 602  Descr.: read data from file
 603  Input : ah      - handle (file) to read from
 604          buffer  - buffer to store data into
 605          length  - size of data to read
 606  Output: read bytes
 607 *******************************************/
 608 LONG readData
 609         (
 610                 struct AFSBase *afsbase,
 611                 struct AfsHandle *ah,
 612                 void *buffer,
 613                 ULONG length,
 614                 SIPTR *error
 615         )
 616 {
 617 struct BlockCache *extensionbuffer;
 618 struct BlockCache *databuffer;
 619 UWORD size;
 620 LONG readbytes=0;
 621 char *source;
 622
 623         if (ah->current.block == 0)
 624                 return 0;                     /* we can't read beyond EOF so return EOF */
 625         if (length > (ah->filesize-ah->current.offset))
 626         {
 627                 length = ah->filesize-ah->current.offset; /* we can't read more bytes than left in file! */
 628         }
 629         D(bug("[afs]   readData: offset=%ld\n", ah->current.offset));
 630         extensionbuffer = getBlock(afsbase, ah->volume, ah->current.block);
 631         if (extensionbuffer == NULL)
 632         {
 633                 *error = ERROR_UNKNOWN;
 634                 return ENDSTREAMCH;
 635         }
 636         extensionbuffer->flags |= BCF_USED; /* don't overwrite that cache block! */
 637         while (length != 0)
 638         {
 639                 D(bug("[afs]   readData: bytes left=%ld\n",length));
 640                 /*
 641                         block, filekey always point to the next block
 642                         so update them if we have read a whole block
 643                 */
 644                 /* do we have to read next extension block? */
 645                 if (ah->current.filekey<BLK_TABLE_START)
 646                 {
 647                         ah->current.block=
 648                                 OS_BE2LONG(extensionbuffer->buffer[BLK_EXTENSION(ah->volume)]);
 649                         ah->current.filekey = BLK_TABLE_END(ah->volume);
 650                         extensionbuffer->flags &= ~BCF_USED;            //we can now overwrite that cache block
 651                         D(bug("[afs]   readData: reading extensionblock=%ld\n",ah->current.block));
 652                         if (ah->current.block != 0)
 653                         {
 654                                 extensionbuffer = getBlock(afsbase, ah->volume,ah->current.block);
 655                                 if (extensionbuffer == 0)
 656                                 {
 657                                         *error = ERROR_UNKNOWN;
 658                                         return ENDSTREAMCH; //was   readbytes;
 659                                 }
 660                                 extensionbuffer->flags |= BCF_USED;     //don't overwrite this cache block
 661                         }
 662 D(
 663                         else
 664                                 if (length)
 665                                         bug
 666                                                 (
 667                                                         "Shit, out of extensionblocks!\n"
 668                                                         "Bytes left: %ld\n"
 669                                                         "Last extensionblock: %ld\n",
 670                                                         length,extensionbuffer->blocknum
 671                                                 );
 672 );
 673                 }
 674                 D(bug
 675                         (
 676                                 "[afs]   readData: reading datablock %ld\n",
 677                                 OS_BE2LONG(extensionbuffer->buffer[ah->current.filekey]))
 678                         );
 679                 databuffer = getBlock
 680                         (
 681                                 afsbase,
 682                                 ah->volume,
 683                                 OS_BE2LONG(extensionbuffer->buffer[ah->current.filekey])
 684                         );
 685                 if (databuffer == 0)
 686                 {
 687                         extensionbuffer->flags &= ~BCF_USED;    //free that block
 688                         *error = ERROR_UNKNOWN;
 689                         return ENDSTREAMCH; //was   readbytes;
 690                 }
 691                 source = (char *)databuffer->buffer+ah->current.byte;
 692                 if (ah->volume->dosflags == 0)
 693                 {
 694                         size = OS_BE2LONG(databuffer->buffer[BLK_DATA_SIZE]);
 695                         source += (BLK_DATA_START*4);
 696                 }
 697                 else
 698                 {
 699                         size = BLOCK_SIZE(ah->volume);
 700                 }
 701                 size -= ah->current.byte;
 702                 if (size > length)
 703                 {
 704                         size = length;
 705                         ah->current.byte += size;
 706                 }
 707                 else
 708                 {
 709                         ah->current.byte = 0;
 710                         ah->current.filekey--;
 711                 }
 712                 CopyMem((APTR)source, (APTR)((char *)buffer+readbytes),size);
 713                 length -= size;
 714                 readbytes += size;
 715         }
 716         extensionbuffer->flags &= ~BCF_USED;
 717         return readbytes;
 718 }
 719
 720 LONG readf
 721         (struct AFSBase *afsbase, struct AfsHandle *ah, void *buffer, ULONG length, SIPTR *error)
 722 {
 723 LONG readbytes;
 724
 725         D(bug("[afs]   read(%ld,buffer,%ld)\n", ah->header_block, length));
 726         readbytes = readData(afsbase, ah,buffer,length, error);
 727         if (readbytes != ENDSTREAMCH)
 728                 ah->current.offset = ah->current.offset+readbytes;
 729         return readbytes;
 730 }
 731
 732 void newFileExtensionBlock
 733         (
 734                 struct Volume *volume,
 735                 struct BlockCache *extension,
 736                 ULONG parent)
 737 {
 738 UWORD i;
 739
 740         extension->buffer[BLK_PRIMARY_TYPE] = OS_LONG2BE(T_LIST);
 741         extension->buffer[BLK_OWN_KEY ] = OS_LONG2BE(extension->blocknum);
 742         for (i=2; i<BLK_PARENT(volume); i++)
 743                 extension->buffer[i] = 0;
 744         extension->buffer[BLK_PARENT(volume)] = OS_LONG2BE(parent);
 745         extension->buffer[BLK_EXTENSION(volume)] = 0;
 746         extension->buffer[BLK_SECONDARY_TYPE(volume)] = OS_LONG2BE(ST_FILE);
 747 }
 748
 749 void writeExtensionBlock
 750         (
 751                 struct AFSBase *afsbase,
 752                 struct Volume *volume,
 753                 struct BlockCache *extension,
 754                 ULONG filekey,
 755                 ULONG next
 756         )
 757 {
 758 ULONG newcount = BLK_TABLE_END(volume)-(filekey-1);
 759
 760         if (OS_BE2LONG(extension->buffer[BLK_BLOCK_COUNT]) < newcount)
 761                 extension->buffer[BLK_BLOCK_COUNT] = OS_LONG2BE(newcount);
 762         if (next != 0)
 763                 extension->buffer[BLK_EXTENSION(volume)] = OS_LONG2BE(next);
 764         writeBlockDeferred(afsbase, volume, extension, BLK_CHECKSUM);
 765 }
 766
 767 LONG writeData
 768         (
 769                 struct AFSBase *afsbase,
 770                 struct AfsHandle *ah,
 771                 void *buffer,
 772                 ULONG length,
 773                 SIPTR *error
 774         )
 775 {
 776 ULONG block = 0;
 777 ULONG lastblock = 0;    /* 0 means: don't update BLK_NEXT_DATA */
 778 struct BlockCache *extensionbuffer = NULL;
 779 struct BlockCache *databuffer = NULL;
 780 UWORD size, blockCapacity;
 781 LONG writtenbytes = 0, sumoffset;
 782 char *destination;
 783 BOOL extensionModified = FALSE;
 784
 785         D(bug("[afs]   writeData: offset=%ld\n", ah->current.offset));
 786         extensionbuffer = getBlock(afsbase, ah->volume, ah->current.block);
 787         if (extensionbuffer == NULL)
 788         {
 789                 *error = ERROR_UNKNOWN;
 790                 return ENDSTREAMCH;
 791         }
 792         extensionbuffer->flags |=BCF_USED;      /* don't overwrite that cache block! */
 793         while (length != 0)
 794         {
 795                 /* save last data block for OFS data */
 796                 if (
 797                                 (ah->current.byte==0) &&                         /* last block fully written */
 798                                 (ah->current.filekey!=BLK_TABLE_END(ah->volume)) /* this is not the first block of the file */
 799                         )
 800                 {
 801                         lastblock = OS_BE2LONG(extensionbuffer->buffer[ah->current.filekey+1]);
 802                         D(bug
 803                                 ("[afs]   writeData: for OFS last datablock was %lu\n", lastblock));
 804                 }
 805                 /*
 806                         block, filekey always point to the last block
 807                         so update them if we have read a whole block
 808                 */
 809                 /* read next extension block? */
 810                 if (ah->current.filekey < BLK_TABLE_START)
 811                 {
 812                         extensionModified = FALSE;
 813                         if (extensionbuffer->buffer[BLK_EXTENSION(ah->volume)] != 0)
 814                         {
 815                                 block = OS_BE2LONG(extensionbuffer->buffer[BLK_EXTENSION(ah->volume)]);
 816                                 extensionbuffer->flags &= ~BCF_USED;
 817                                 extensionbuffer = getBlock(afsbase, ah->volume, block);
 818                                 if (extensionbuffer == NULL)
 819                                 {
 820                                         *error = ERROR_UNKNOWN;
 821                                         return ENDSTREAMCH; // was   writtenbytes;
 822                                 }
 823                         }
 824                         else
 825                         {
 826                                 D(bug("[afs]   writeData: need new extensionblock\n"));
 827                                 block = allocBlock(afsbase, ah->volume);
 828                                 writeExtensionBlock
 829                                         (
 830                                                 afsbase,
 831                                                 ah->volume,
 832                                                 extensionbuffer,
 833                                                 ah->current.filekey+1,
 834                                                 block
 835                                         );
 836                                 extensionbuffer->flags &= ~BCF_USED;
 837                                 if (block == 0)
 838                                 {
 839                                         *error = ERROR_NO_FREE_STORE;
 840                                         return ENDSTREAMCH; /* was   writtenbytes; */
 841                                 }
 842                                 extensionbuffer = getFreeCacheBlock(afsbase, ah->volume,block);
 843                                 if (extensionbuffer == NULL)
 844                                 {
 845                                         *error = ERROR_UNKNOWN;
 846                                         return ENDSTREAMCH; /* was   writtenbytes; */
 847                                 }
 848                                 newFileExtensionBlock(ah->volume,extensionbuffer, ah->header_block);
 849                         }
 850                         ah->current.filekey = BLK_TABLE_END(ah->volume);
 851                         extensionbuffer->flags |= BCF_USED;     /* don't overwrite this cache block */
 852                         ah->current.block = block;
 853                 }
 854                 /* find a block to write data into */
 855                 if (extensionbuffer->buffer[ah->current.filekey] != 0) /* do we already have that block? */
 856                 {
 857                         D(bug
 858                                 (
 859                                         "[afs]   writeData: using old datablock %lu\n",
 860                                         OS_BE2LONG(extensionbuffer->buffer[ah->current.filekey]))
 861                                 );
 862                         /* Only get the block's old contents if some of it won't be overwritten
 863                            (except for OFS or a final, partially-used block) */
 864                         block = OS_BE2LONG(extensionbuffer->buffer[ah->current.filekey]);
 865                         if ((ah->current.byte == 0) && (length >= BLOCK_SIZE(ah->volume))
 866                                 && (ah->volume->dosflags != 0))
 867                                 databuffer = getFreeCacheBlock(afsbase, ah->volume, block);
 868                         else
 869                                 databuffer = getBlock(afsbase, ah->volume, block);
 870                         if (databuffer == NULL)
 871                         {
 872                                 writeExtensionBlock
 873                                         (
 874                                                 afsbase,
 875                                                 ah->volume,
 876                                                 extensionbuffer,
 877                                                 ah->current.filekey,
 878                                                 0
 879                                         );
 880                                 extensionbuffer->flags &= ~BCF_USED;    //free that block
 881                                 *error = ERROR_UNKNOWN;
 882                                 return ENDSTREAMCH; //was   writtenbytes;
 883                         }
 884                 }
 885                 else
 886                 {
 887                         extensionModified = TRUE;
 888                         D(bug("[afs]   writeData: need a new datablock\n"));
 889                         block=allocBlock(afsbase, ah->volume);
 890                         if (block == 0)
 891                         {
 892                                 writeExtensionBlock
 893                                         (
 894                                                 afsbase,
 895                                                 ah->volume,
 896                                                 extensionbuffer,
 897                                                 ah->current.filekey,
 898                                                 0
 899                                         );
 900                                 extensionbuffer->flags &= ~BCF_USED;
 901                                 *error = ERROR_NO_FREE_STORE;
 902                                 return ENDSTREAMCH; //was   writtenbytes;
 903                         }
 904                         extensionbuffer->buffer[ah->current.filekey] = OS_LONG2BE(block);
 905                         if ((ah->volume->dosflags==0) && (lastblock != 0))
 906                         {
 907                                 D(bug("[afs]   writeData: OFS->fill in %ld BLK_NEXT_DATA\n",lastblock));
 908                                 /*
 909                                          we allocated a new block
 910                                         so there MUST be an initialized lastblock
 911                                 */
 912                                 databuffer = getBlock(afsbase, ah->volume,lastblock);
 913                                 if (databuffer == NULL)
 914                                 {
 915                                         writeExtensionBlock
 916                                                 (
 917                                                         afsbase,
 918                                                         ah->volume,
 919                                                         extensionbuffer,
 920                                                         ah->current.filekey,
 921                                                         0
 922                                                 );
 923                                         extensionbuffer->flags &= ~BCF_USED;    //free that block
 924                                         *error = ERROR_UNKNOWN;
 925                                         return ENDSTREAMCH; //was   writtenbytes;
 926                                 }
 927                                 databuffer->buffer[BLK_NEXT_DATA] = OS_LONG2BE(block);
 928                                 writeBlock(afsbase, ah->volume,databuffer, BLK_CHECKSUM);
 929                         }
 930                         databuffer = getFreeCacheBlock(afsbase, ah->volume,block);
 931                         if (databuffer == NULL)
 932                         {
 933                                 writeExtensionBlock
 934                                         (afsbase, ah->volume, extensionbuffer, ah->current.filekey, 0);
 935                                 extensionbuffer->flags &= ~BCF_USED;    //free that block
 936                                 *error = ERROR_UNKNOWN;
 937                                 return ENDSTREAMCH; //was   writtenbytes;
 938                         }
 939                         if (ah->volume->dosflags == 0)
 940                         {
 941                                 databuffer->buffer[BLK_PRIMARY_TYPE] = OS_LONG2BE(T_DATA);
 942                                 databuffer->buffer[BLK_HEADER_KEY] = OS_LONG2BE(ah->header_block);
 943                                 blockCapacity = (ah->volume->SizeBlock-BLK_DATA_START)*sizeof(ULONG);
 944                                 databuffer->buffer[BLK_SEQUENCE_NUMBER] =
 945                                         OS_LONG2BE
 946                                                 (((ah->current.offset+writtenbytes)/blockCapacity)+1);
 947                                 databuffer->buffer[BLK_DATA_SIZE] = 0;
 948                                 databuffer->buffer[BLK_NEXT_DATA] = 0;
 949                         }
 950                 }
 951                 destination = (char *)databuffer->buffer+ah->current.byte;
 952                 size = BLOCK_SIZE(ah->volume);
 953                 if (ah->volume->dosflags == 0)
 954                 {
 955                         size -= (6*4);
 956                         destination += (BLK_DATA_START*4);
 957                 }
 958                 size -= ah->current.byte;
 959                 if (size > length)
 960                 {
 961                         size = length;
 962                         ah->current.byte += size;
 963                 }
 964                 else
 965                 {
 966                         ah->current.byte = 0;
 967                         ah->current.filekey--;
 968                 }
 969                 if (buffer != NULL)
 970                         CopyMem((APTR)((char *)buffer+writtenbytes),(APTR)destination,size);
 971                 if (ah->volume->dosflags == 0)
 972                 {
 973                         if (ah->current.byte == 0)
 974                         {
 975                                 databuffer->buffer[BLK_DATA_SIZE] =
 976                                         OS_LONG2BE(BLOCK_SIZE(ah->volume)-(6*4));
 977                         }
 978                         else if (OS_BE2LONG(databuffer->buffer[BLK_DATA_SIZE]) < ah->current.byte)
 979                         {
 980                                 databuffer->buffer[BLK_DATA_SIZE] = OS_LONG2BE(ah->current.byte);
 981                         }
 982                         sumoffset = BLK_CHECKSUM;
 983                 }
 984                 else
 985                         sumoffset = -1;
 986                 if (buffer != NULL || ah->volume->dosflags == 0)
 987                         writeBlock(afsbase, ah->volume, databuffer, sumoffset);
 988                 length -= size;
 989                 writtenbytes += size;
 990         }
 991         if (extensionModified)
 992         {
 993                 writeExtensionBlock
 994                         (
 995                                 afsbase,
 996                                 ah->volume,
 997                                 extensionbuffer,
 998                                 ah->current.byte==0 ? ah->current.filekey+1 : ah->current.filekey,
 999                                 0
1000                         );
1001         }
1002         extensionbuffer->flags &= ~BCF_USED;
1003         D(bug("[afs]   writeData=%ld\n", writtenbytes));
1004         return writtenbytes;
1005 }
1006
1007 LONG writef
1008         (struct AFSBase *afsbase, struct AfsHandle *ah, void *buffer, ULONG length, SIPTR *error)
1009 {
1010 struct BlockCache *headerblock;
1011 LONG writtenbytes;
1012 struct DateStamp ds;
1013
1014         D(bug("[afs] write(ah,buffer,%ld)\n", length));
1015         if (0 == checkValid(afsbase, ah->volume))
1016         {
1017                 *error = ERROR_DISK_WRITE_PROTECTED;
1018                 return 0;
1019         }
1020
1021         invalidBitmap(afsbase, ah->volume);
1022         writtenbytes = writeData(afsbase, ah, buffer, length, error);
1023         if (writtenbytes != ENDSTREAMCH)
1024         {
1025                 ah->current.offset += writtenbytes;
1026                 headerblock = getBlock(afsbase, ah->volume,ah->header_block);
1027                 if (headerblock != NULL)
1028                 {
1029                         headerblock->buffer[BLK_FIRST_DATA] =
1030                                 headerblock->buffer[BLK_TABLE_END(ah->volume)];
1031                         if (ah->current.offset > ah->filesize)
1032                         {
1033                                 ah->filesize = ah->current.offset;
1034                                 headerblock->buffer[BLK_BYTE_SIZE(ah->volume)] =
1035                                         OS_LONG2BE(ah->filesize);
1036                         }
1037                         DateStamp(&ds);
1038                         setHeaderDate(afsbase, ah->volume, headerblock, &ds);
1039                 }
1040         }
1041         validBitmap(afsbase, ah->volume);
1042         return writtenbytes;
1043 }
1044
1045 LONG seek
1046         (struct AFSBase* afsbase, struct AfsHandle *ah, LONG offset, LONG mode, SIPTR *error)
1047 {
1048 LONG old = -1;
1049 UWORD filekey, byte;
1050 ULONG block, extblockindex, newextblockindex;
1051 UWORD blocksize, tablesize;
1052 ULONG newoffset;
1053 struct BlockCache *blockbuffer;
1054
1055         D(bug("[afs] seek(%ld,%ld,%ld)\n", ah->header_block, offset, mode));
1056         *error = ERROR_SEEK_ERROR;
1057         if (mode == OFFSET_BEGINNING)
1058         {
1059                 newoffset = (ULONG)offset;
1060         }
1061         else if (mode == OFFSET_CURRENT)
1062         {
1063                 if (offset == 0)
1064                 {
1065                         *error = 0;
1066                         return ah->current.offset;
1067                 }
1068                 newoffset = ah->current.offset+offset;
1069         }
1070         else if (mode == OFFSET_END)
1071         {
1072                 newoffset = ah->filesize+offset;
1073         }
1074         else
1075                 return -1;
1076         if ((LONG)newoffset >= 0)
1077         {
1078                 blocksize = BLOCK_SIZE(ah->volume);
1079                 if (ah->volume->dosflags == 0)
1080                         blocksize -= (BLK_DATA_START*4);
1081                 newextblockindex = newoffset / blocksize;
1082                 tablesize = BLK_TABLE_END(ah->volume)-BLK_TABLE_START+1;
1083                 filekey = BLK_TABLE_END(ah->volume)-(newextblockindex % tablesize);
1084                 newextblockindex /= tablesize; /* # of extensionblock we need */
1085                 byte = newoffset % blocksize;
1086                 if (newoffset != 0 && byte == 0 && filekey == BLK_TABLE_END(ah->volume))
1087                 {
1088                         newextblockindex--;
1089                         filekey = BLK_TABLE_START - 1;
1090                 }
1091
1092                 /* Get index of current extension block */
1093                 extblockindex = (ah->current.offset / blocksize) / tablesize;
1094                 if (ah->current.filekey<BLK_TABLE_START)
1095                         extblockindex--;
1096
1097                 /* Start at current extension block, unless we have to go back to
1098                    a previous extension block */
1099                 if (newextblockindex >= extblockindex)
1100                         block = ah->current.block;
1101                 else
1102                 {
1103                         block = ah->header_block;
1104                         extblockindex = 0;
1105                 }
1106
1107                 while ((extblockindex != newextblockindex) && (block != 0))
1108                 {
1109                         blockbuffer = getBlock(afsbase, ah->volume, block);
1110                         if (blockbuffer == NULL)
1111                                 return -1;
1112                         block = OS_BE2LONG(blockbuffer->buffer[BLK_EXTENSION(ah->volume)]);
1113                         extblockindex++;
1114                 }
1115                 if (block != 0)
1116                 {
1117                         *error = 0;
1118                         old = ah->current.offset;
1119                         ah->current.block = block;
1120                         ah->current.filekey = filekey;
1121                         ah->current.byte = byte;
1122                         ah->current.offset = newoffset;
1123                 }
1124         }
1125         return old;
1126 }
1127
1128 LONG setFileSize
1129         (struct AFSBase* afsbase, struct AfsHandle *ah, LONG size, LONG mode, SIPTR *error)
1130 {
1131 LONG pos = -1, extra, savederror, newsize;
1132 struct BlockCache *headerblock;
1133 struct DateStamp ds;
1134 struct AfsHandle *ah2;
1135
1136         if (0 == checkValid(afsbase, ah->volume))
1137         {
1138                 *error = ERROR_DISK_WRITE_PROTECTED;
1139                 return -1;
1140         }
1141
1142         /* Get absolute new length */
1143         D(bug("[afs] setfilesize(%ld,%ld,%ld)\n", ah->header_block, size, mode));
1144         *error = ERROR_SEEK_ERROR;
1145         if (mode == OFFSET_BEGINNING)
1146         {
1147                 newsize = 0;
1148         }
1149         else if (mode == OFFSET_CURRENT)
1150         {
1151                 newsize = ah->current.offset;
1152         }
1153         else if (mode == OFFSET_END)
1154         {
1155                 newsize = ah->filesize;
1156         }
1157         else
1158                 return -1;
1159
1160         /* Ensure new length isn't negative */
1161         if (-size > newsize)
1162         {
1163                 return -1;
1164         }
1165         newsize += size;
1166
1167         /* Ensure there aren't any other filehandles positioned after the new
1168            length */
1169         for (ah2 = ah->volume->locklist; ah2 != NULL; ah2 = ah2->next)
1170         {
1171                         if (ah2 != ah && ah2->header_block == ah->header_block
1172                                 && ah2->current.offset > newsize)
1173                                 return -1;
1174         }
1175
1176         /* Lengthen or shorten file */
1177         pos = ah->current.offset;
1178         if (newsize > ah->filesize)
1179         {
1180                 seek(afsbase, ah, 0, OFFSET_END, error);
1181                 invalidBitmap(afsbase, ah->volume);
1182                 extra = writeData(afsbase, ah, NULL, newsize - ah->filesize, error);
1183                 validBitmap(afsbase, ah->volume);
1184
1185                 /* Revert to original size if we couldn't fully lengthen the file */
1186                 if (extra < newsize - ah->filesize)
1187                 {
1188                         savederror = *error;
1189                         setFileSize(afsbase, ah, ah->filesize, OFFSET_BEGINNING, error);
1190                         *error = savederror;
1191                         return -1;
1192                 }
1193         }
1194         else
1195         {
1196                 seek(afsbase, ah, newsize, OFFSET_BEGINNING, error);
1197                 deleteFileRemainder(afsbase, ah);
1198                 if (pos < newsize)
1199                         pos = newsize;
1200         }
1201         *error = 0;
1202
1203         /* Update metadata */
1204         headerblock = getBlock(afsbase, ah->volume, ah->header_block);
1205         if (headerblock != NULL)
1206         {
1207                 ah->filesize = newsize;
1208                 headerblock->buffer[BLK_BYTE_SIZE(ah->volume)] =
1209                         OS_LONG2BE(ah->filesize);
1210                 DateStamp(&ds);
1211                 setHeaderDate(afsbase, ah->volume, headerblock, &ds);
1212         }
1213         seek(afsbase, ah, pos, OFFSET_BEGINNING, error);
1214
1215         return newsize;
1216 }
1217