tools/adflib/adf_cache.c

   1 /*
   2  *  ADF Library. (C) 1997-1999 Laurent Clevy
   3  *
   4  *  adf_cache.c
   5  *
   6  */
   7
   8 #include<stdlib.h>
   9 #include<string.h>
  10
  11 #include"adf_defs.h"
  12 #include"adf_str.h"
  13 #include"adf_err.h"
  14 #include"defendian.h"
  15 #include"adf_cache.h"
  16 #include"adf_raw.h"
  17 #include"adf_disk.h"
  18 #include"adf_bitm.h"
  19 #include"adf_util.h"
  20 #include"adf_dir.h"
  21
  22
  23 extern struct Env adfEnv;
  24 /*
  25 freeEntCache(struct CacheEntry *cEntry)
  26 {
  27     if (cEntry->name!=NULL)
  28         free(cEntry->name);
  29     if (cEntry->comm!=NULL)
  30         free(cEntry->comm);
  31 }
  32 */
  33
  34 /*
  35  * adfGetDirEntCache
  36  *
  37  * replace 'adfGetDirEnt'. returns a the dir contents based on the dircache list
  38  */
  39 struct List* adfGetDirEntCache(struct Volume *vol, SECTNUM dir, BOOL recurs)
  40 {
  41         struct bEntryBlock parent;
  42         struct bDirCacheBlock dirc;
  43     int offset, n;
  44     struct List *cell, *head;
  45     struct CacheEntry caEntry;
  46     struct Entry *entry;
  47     SECTNUM nSect;
  48
  49     if (adfReadEntryBlock(vol,dir,&parent)!=RC_OK)
  50         return NULL;
  51
  52     nSect = parent.extension;
  53
  54     cell = head = NULL;
  55     do {
  56         /* one loop per cache block */
  57         n = offset = 0;
  58             if (adfReadDirCBlock(vol, nSect, &dirc)!=RC_OK)
  59             return NULL;
  60         while (n<dirc.recordsNb) {
  61             /* one loop per record */
  62             entry = (struct Entry*)malloc(sizeof(struct Entry));
  63             if (!entry) {
  64                 adfFreeDirList(head);
  65                 return NULL;
  66             }
  67             adfGetCacheEntry(&dirc, &offset, &caEntry);
  68
  69             /* converts a cache entry into a dir entry */
  70             entry->type = (int)caEntry.type;
  71             entry->name = strdup(caEntry.name);
  72             if (entry->name==NULL) {
  73                 free(entry); adfFreeDirList(head);
  74                 return NULL;
  75             }
  76             entry->sector = caEntry.header;
  77             entry->comment = strdup(caEntry.comm);
  78             if (entry->comment==NULL) {
  79                 free(entry->name); adfFreeDirList(head);
  80                 return NULL;
  81             }
  82             entry->size = caEntry.size;
  83             entry->access = caEntry.protect;
  84             adfDays2Date( caEntry.days, &(entry->year), &(entry->month),
  85                 &(entry->days) );
  86             entry->hour = caEntry.mins/60;
  87             entry->mins = caEntry.mins%60;
  88             entry->secs = caEntry.ticks/50;
  89
  90             /* add it into the linked list */
  91             if (head==NULL)
  92                 head = cell = newCell(NULL, (void*)entry);
  93             else
  94                 cell = newCell(cell, (void*)entry);
  95
  96             if (cell==NULL) {
  97                 adfFreeEntry(entry);
  98                 adfFreeDirList(head);
  99                 return NULL;
 100             }
 101
 102             if (recurs && entry->type==ST_DIR)
 103                  cell->subdir = adfGetDirEntCache(vol,entry->sector,recurs);
 104
 105             n++;
 106         }
 107         nSect = dirc.nextDirC;
 108     }while (nSect!=0);
 109
 110     return head;
 111 }
 112
 113
 114
 115 /*
 116  * adfGetCacheEntry
 117  *
 118  * Returns a cache entry, starting from the offset p (the index into records[])
 119  * This offset is updated to the end of the returned entry.
 120  */
 121 void adfGetCacheEntry(struct bDirCacheBlock *dirc, int *p, struct CacheEntry *cEntry)
 122 {
 123     int ptr;
 124
 125     ptr = *p;
 126
 127 //printf("p=%d\n",ptr);
 128
 129 #ifdef LITT_ENDIAN
 130     cEntry->header = swapLong(dirc->records+ptr);
 131     cEntry->size = swapLong(dirc->records+ptr+4);
 132     cEntry->protect = swapLong(dirc->records+ptr+8);
 133     cEntry->days = swapShort(dirc->records+ptr+16);
 134     cEntry->mins = swapShort(dirc->records+ptr+18);
 135     cEntry->ticks = swapShort(dirc->records+ptr+20);
 136 #else
 137     cEntry->header = Long(dirc->records+ptr);
 138     cEntry->size = Long(dirc->records+ptr+4);
 139     cEntry->protect = Long(dirc->records+ptr+8);
 140     cEntry->days = Short(dirc->records+ptr+16);
 141     cEntry->mins = Short(dirc->records+ptr+18);
 142     cEntry->ticks = Short(dirc->records+ptr+20);
 143 #endif
 144     cEntry->type =(signed char) dirc->records[ptr+22];
 145
 146     cEntry->nLen = dirc->records[ptr+23];
 147 /*    cEntry->name = (char*)malloc(sizeof(char)*(cEntry->nLen+1));
 148     if (!cEntry->name)
 149          return;
 150 */    memcpy(cEntry->name, dirc->records+ptr+24, cEntry->nLen);
 151     cEntry->name[(int)(cEntry->nLen)]='\0';
 152
 153     cEntry->cLen = dirc->records[ptr+24+cEntry->nLen];
 154     if (cEntry->cLen>0) {
 155 /*        cEntry->comm =(char*)malloc(sizeof(char)*(cEntry->cLen+1));
 156         if (!cEntry->comm) {
 157             free( cEntry->name ); cEntry->name=NULL;
 158             return;
 159         }
 160 */        memcpy(cEntry->comm,dirc->records+ptr+24+cEntry->nLen+1,cEntry->cLen);
 161     }
 162         cEntry->comm[(int)(cEntry->cLen)]='\0';
 163 //printf("cEntry->nLen %d cEntry->cLen %d %s\n",cEntry->nLen,cEntry->cLen,cEntry->name);
 164     *p  = ptr+24+cEntry->nLen+1+cEntry->cLen;
 165
 166     /* the starting offset of each record must be even (68000 constraint) */
 167     if ((*p%2)!=0)
 168         *p=(*p)+1;
 169 }
 170
 171
 172 /*
 173  * adfPutCacheEntry
 174  *
 175  * remplaces one cache entry at the p offset, and returns its length
 176  */
 177 int adfPutCacheEntry( struct bDirCacheBlock *dirc, int *p, struct CacheEntry *cEntry)
 178 {
 179     int ptr, l;
 180
 181     ptr = *p;
 182
 183 #ifdef LITT_ENDIAN
 184     swLong(dirc->records+ptr, cEntry->header);
 185     swLong(dirc->records+ptr+4, cEntry->size);
 186     swLong(dirc->records+ptr+8, cEntry->protect);
 187     swShort(dirc->records+ptr+16, cEntry->days);
 188     swShort(dirc->records+ptr+18, cEntry->mins);
 189     swShort(dirc->records+ptr+20, cEntry->ticks);
 190 #else
 191     memcpy(dirc->records+ptr,&(cEntry->header),4);
 192     memcpy(dirc->records+ptr+4,&(cEntry->size),4);
 193     memcpy(dirc->records+ptr+8,&(cEntry->protect),4);
 194     memcpy(dirc->records+ptr+16,&(cEntry->days),2);
 195     memcpy(dirc->records+ptr+18,&(cEntry->mins),2);
 196     memcpy(dirc->records+ptr+20,&(cEntry->ticks),2);
 197 #endif
 198     dirc->records[ptr+22] =(signed char)cEntry->type;
 199
 200     dirc->records[ptr+23] = cEntry->nLen;
 201     memcpy(dirc->records+ptr+24, cEntry->name, cEntry->nLen);
 202
 203     dirc->records[ptr+24+cEntry->nLen] = cEntry->cLen;
 204     memcpy(dirc->records+ptr+24+cEntry->nLen+1, cEntry->comm, cEntry->cLen);
 205
 206 //puts("adfPutCacheEntry");
 207
 208     l = 25+cEntry->nLen+cEntry->cLen;
 209     if ((l%2)==0)
 210         return l;
 211     else {
 212         dirc->records[ptr+l] =(char)0;
 213         return l+1;
 214     }
 215
 216     /* ptr%2 must be == 0, if l%2==0, (ptr+l)%2==0 */
 217 }
 218
 219
 220 /*
 221  * adfEntry2CacheEntry
 222  *
 223  * converts one dir entry into a cache entry, and return its future length in records[]
 224  */
 225 int adfEntry2CacheEntry(struct bEntryBlock *entry, struct CacheEntry *newEntry)
 226 {
 227     int entryLen;
 228
 229     /* new entry */
 230     newEntry->header = entry->headerKey;
 231     if (entry->secType==ST_FILE)
 232         newEntry->size = entry->byteSize;
 233     else
 234         newEntry->size = 0L;
 235     newEntry->protect = entry->access;
 236     newEntry->days = (short)entry->days;
 237     newEntry->mins = (short)entry->mins;
 238     newEntry->ticks  = (short)entry->ticks;
 239     newEntry->type = (signed char)entry->secType;
 240     newEntry->nLen = entry->nameLen;
 241     memcpy(newEntry->name, entry->name, newEntry->nLen);
 242     newEntry->name[(int)(newEntry->nLen)] = '\0';
 243     newEntry->cLen = entry->commLen;
 244     if (newEntry->cLen>0)
 245         memcpy(newEntry->comm, entry->comment, newEntry->cLen);
 246
 247     entryLen = 24+newEntry->nLen+1+newEntry->cLen;
 248
 249 /*printf("entry->name %d entry->comment %d\n",entry->nameLen,entry->commLen);
 250 printf("newEntry->nLen %d newEntry->cLen %d\n",newEntry->nLen,newEntry->cLen);
 251 */    if ((entryLen%2)==0)
 252         return entryLen;
 253     else
 254         return entryLen+1;
 255 }
 256
 257
 258 /*
 259  * adfDelFromCache
 260  *
 261  * delete one cache entry from its block. don't do 'records garbage collecting'
 262  */
 263 RETCODE adfDelFromCache(struct Volume *vol, struct bEntryBlock *parent,
 264     SECTNUM headerKey)
 265 {
 266     struct bDirCacheBlock dirc;
 267     SECTNUM nSect, prevSect;
 268     struct CacheEntry caEntry;
 269     int offset, oldOffset, n;
 270     BOOL found;
 271     int entryLen;
 272     int i;
 273     RETCODE rc = RC_OK;
 274
 275     prevSect = -1;
 276         nSect = parent->extension;
 277     found = FALSE;
 278     do {
 279         adfReadDirCBlock(vol, nSect, &dirc);
 280         offset = 0; n = 0;
 281         while(n < dirc.recordsNb && !found) {
 282             oldOffset = offset;
 283             adfGetCacheEntry(&dirc, &offset, &caEntry);
 284             found = (caEntry.header==headerKey);
 285             if (found) {
 286                 entryLen = offset-oldOffset;
 287                 if (dirc.recordsNb>1 || prevSect==-1) {
 288                     if (n<dirc.recordsNb-1) {
 289                         /* not the last of the block : switch the following records */
 290                         for(i=oldOffset; i<(488-entryLen); i++)
 291                             dirc.records[i] = dirc.records[i+entryLen];
 292                         /* and clear the following bytes */
 293                         for(i=488-entryLen; i<488; i++)
 294                             dirc.records[i] = 0;
 295                     }
 296                     else {
 297                         /* the last record of this cache block */
 298                         for(i=oldOffset; i<offset; i++)
 299                             dirc.records[i] = 0;
 300                     }
 301                     dirc.recordsNb--;
 302                     if (adfWriteDirCBlock(vol, dirc.headerKey, &dirc)!=RC_OK)
 303                                                 return -1;
 304                 }
 305                 else {
 306                     /* dirc.recordsNb ==1 or == 0 , prevSect!=-1 :
 307                     * the only record in this dirc block and a previous dirc block exists
 308                     */
 309                     adfSetBlockFree(vol, dirc.headerKey);
 310                     adfReadDirCBlock(vol, prevSect, &dirc);
 311                     dirc.nextDirC = 0L;
 312                     adfWriteDirCBlock(vol, prevSect, &dirc);
 313
 314                     adfUpdateBitmap(vol);
 315                 }
 316             }
 317             n++;
 318         }
 319         prevSect = nSect;
 320         nSect = dirc.nextDirC;
 321     }while(nSect!=0 && !found);
 322
 323     if (!found)
 324         (*adfEnv.wFct)("adfUpdateCache : entry not found");
 325
 326     return rc;
 327 }
 328
 329
 330 /*
 331  * adfAddInCache
 332  *
 333  */
 334 RETCODE adfAddInCache(struct Volume *vol, struct bEntryBlock *parent,
 335     struct bEntryBlock *entry)
 336 {
 337     struct bDirCacheBlock dirc, newDirc;
 338     SECTNUM nSect, nCache;
 339     struct CacheEntry caEntry, newEntry;
 340     int offset, n;
 341     int entryLen;
 342
 343     entryLen = adfEntry2CacheEntry(entry, &newEntry);
 344 /*printf("adfAddInCache--%4ld %2d %6ld %8lx %4d %2d:%02d:%02d %30s %22s\n",
 345     newEntry.header, newEntry.type, newEntry.size, newEntry.protect,
 346     newEntry.days, newEntry.mins/60, newEntry.mins%60,
 347         newEntry.ticks/50,
 348         newEntry.name, newEntry.comm);
 349 */
 350     nSect = parent->extension;
 351     do {
 352         if (adfReadDirCBlock(vol, nSect, &dirc)!=RC_OK)
 353             return RC_ERROR;
 354         offset = 0; n = 0;
 355 //printf("parent=%4ld\n",dirc.parent);
 356         while(n < dirc.recordsNb) {
 357             adfGetCacheEntry(&dirc, &offset, &caEntry);
 358 /*printf("*%4ld %2d %6ld %8lx %4d %2d:%02d:%02d %30s %22s\n",
 359     caEntry.header, caEntry.type, caEntry.size, caEntry.protect,
 360     caEntry.days, caEntry.mins/60, caEntry.mins%60,
 361         caEntry.ticks/50,
 362         caEntry.name, caEntry.comm);
 363 */
 364             n++;
 365         }
 366
 367 /*        if (offset+entryLen<=488) {
 368             adfPutCacheEntry(&dirc, &offset, &newEntry);
 369             dirc.recordsNb++;
 370             adfWriteDirCBlock(vol, dirc.headerKey, &dirc);
 371             return rc;
 372         }*/
 373         nSect = dirc.nextDirC;
 374     }while(nSect!=0);
 375
 376     /* in the last block */
 377     if (offset+entryLen<=488) {
 378         adfPutCacheEntry(&dirc, &offset, &newEntry);
 379         dirc.recordsNb++;
 380 //printf("entry name=%s\n",newEntry.name);
 381     }
 382     else {
 383         /* request one new block free */
 384         nCache = adfGet1FreeBlock(vol);
 385         if (nCache==-1) {
 386            (*adfEnv.wFct)("adfCreateDir : nCache==-1");
 387            return RC_VOLFULL;
 388         }
 389
 390         /* create a new dircache block */
 391         memset(&newDirc,0,512);
 392         if (parent->secType==ST_ROOT)
 393             newDirc.parent = vol->rootBlock;
 394         else if (parent->secType==ST_DIR)
 395             newDirc.parent = parent->headerKey;
 396         else
 397             (*adfEnv.wFct)("adfAddInCache : unknown secType");
 398         newDirc.recordsNb = 0L;
 399         newDirc.nextDirC = 0L;
 400
 401         adfPutCacheEntry(&dirc, &offset, &newEntry);
 402         newDirc.recordsNb++;
 403         if (adfWriteDirCBlock(vol, nCache, &newDirc)!=RC_OK)
 404                         return RC_ERROR;
 405         dirc.nextDirC = nCache;
 406     }
 407 //printf("dirc.headerKey=%ld\n",dirc.headerKey);
 408     if (adfWriteDirCBlock(vol, dirc.headerKey, &dirc)!=RC_OK)
 409                 return RC_ERROR;
 410 /*if (strcmp(entry->name,"file_5u")==0)
 411 dumpBlock(&dirc);
 412 */
 413     return RC_OK;
 414 }
 415
 416
 417 /*
 418  * adfUpdateCache
 419  *
 420  */
 421 RETCODE adfUpdateCache(struct Volume *vol, struct bEntryBlock *parent,
 422     struct bEntryBlock *entry, BOOL entryLenChg)
 423 {
 424     struct bDirCacheBlock dirc;
 425     SECTNUM nSect;
 426     struct CacheEntry caEntry, newEntry;
 427     int offset, oldOffset, n;
 428     BOOL found;
 429     int i, oLen, nLen;
 430     int sLen; /* shift length */
 431
 432     nLen = adfEntry2CacheEntry(entry, &newEntry);
 433
 434     nSect = parent->extension;
 435     found = FALSE;
 436     do {
 437 //printf("dirc=%ld\n",nSect);
 438         if (adfReadDirCBlock(vol, nSect, &dirc)!=RC_OK)
 439                         return RC_ERROR;
 440         offset = 0; n = 0;
 441         /* search entry to update with its header_key */
 442         while(n < dirc.recordsNb && !found) {
 443             oldOffset = offset;
 444             /* offset is updated */
 445             adfGetCacheEntry(&dirc, &offset, &caEntry);
 446             oLen = offset-oldOffset;
 447             sLen = oLen-nLen;
 448 //printf("olen=%d nlen=%d\n",oLen,nLen);
 449             found = (caEntry.header==newEntry.header);
 450             if (found) {
 451                 if (!entryLenChg || oLen==nLen) {
 452                     /* same length : remplace the old values */
 453                     adfPutCacheEntry(&dirc, &oldOffset, &newEntry);
 454 //if (entryLenChg) puts("oLen==nLen");
 455                     if (adfWriteDirCBlock(vol, dirc.headerKey, &dirc)!=RC_OK)
 456                         return RC_ERROR;
 457                 }
 458                 else if (oLen>nLen) {
 459 //puts("oLen>nLen");
 460                     /* the new record is shorter, write it,
 461                      * then shift down the following records
 462                      */
 463                     adfPutCacheEntry(&dirc, &oldOffset, &newEntry);
 464                     for(i=oldOffset+nLen; i<(488-sLen); i++)
 465                         dirc.records[i] = dirc.records[i+sLen];
 466                     /* then clear the following bytes */
 467                     for(i=488-sLen; i<488; i++)
 468                         dirc.records[i] = (char)0;
 469
 470                     if (adfWriteDirCBlock(vol, dirc.headerKey, &dirc)!=RC_OK)
 471                         return RC_ERROR;
 472                 }
 473                 else {
 474                     /* the new record is larger */
 475 //puts("oLen<nLen");
 476                     adfDelFromCache(vol,parent,entry->headerKey);
 477                     adfAddInCache(vol,parent,entry);
 478 //puts("oLen<nLen end");
 479
 480                 }
 481             }
 482             n++;
 483         }
 484         nSect = dirc.nextDirC;
 485     }while(nSect!=0 && !found);
 486
 487     if (found) {
 488         if (adfUpdateBitmap(vol)!=RC_OK)
 489                         return RC_ERROR;
 490     }
 491     else
 492         (*adfEnv.wFct)("adfUpdateCache : entry not found");
 493
 494     return RC_OK;
 495 }
 496
 497
 498 /*
 499  * adfCreateEmptyCache
 500  *
 501  */
 502 RETCODE adfCreateEmptyCache(struct Volume *vol, struct bEntryBlock *parent, SECTNUM nSect)
 503 {
 504     struct bDirCacheBlock dirc;
 505     SECTNUM nCache;
 506
 507     if (nSect==-1) {
 508         nCache = adfGet1FreeBlock(vol);
 509         if (nCache==-1) {
 510            (*adfEnv.wFct)("adfCreateDir : nCache==-1");
 511            return RC_VOLFULL;
 512         }
 513     }
 514     else
 515         nCache = nSect;
 516
 517     if (parent->extension==0)
 518                 parent->extension = nCache;
 519
 520     memset(&dirc,0, sizeof(struct bDirCacheBlock));
 521
 522     if (parent->secType==ST_ROOT)
 523         dirc.parent = vol->rootBlock;
 524     else if (parent->secType==ST_DIR)
 525         dirc.parent = parent->headerKey;
 526     else {
 527         (*adfEnv.wFct)("adfCreateEmptyCache : unknown secType");
 528 //printf("secType=%ld\n",parent->secType);
 529     }
 530
 531     dirc.recordsNb = 0;
 532     dirc.nextDirC = 0;
 533
 534     if (adfWriteDirCBlock(vol, nCache, &dirc)!=RC_OK)
 535                 return RC_ERROR;
 536
 537     return RC_OK;
 538 }
 539
 540
 541 /*
 542  * adfReadDirCBlock
 543  *
 544  */
 545 RETCODE adfReadDirCBlock(struct Volume *vol, SECTNUM nSect, struct bDirCacheBlock *dirc)
 546 {
 547     unsigned char buf[512];
 548
 549     if (adfReadBlock(vol, nSect, buf)!=RC_OK)
 550                 return RC_ERROR;
 551
 552     memcpy(dirc,buf,512);
 553 #ifdef LITT_ENDIAN
 554     swapEndian((unsigned char*)dirc,SWBL_CACHE);
 555 #endif
 556     if (dirc->checkSum!=adfNormalSum(buf,20,512))
 557         (*adfEnv.wFct)("adfReadDirCBlock : invalid checksum");
 558     if (dirc->type!=T_DIRC)
 559         (*adfEnv.wFct)("adfReadDirCBlock : T_DIRC not found");
 560     if (dirc->headerKey!=nSect)
 561         (*adfEnv.wFct)("adfReadDirCBlock : headerKey!=nSect");
 562
 563     return RC_OK;
 564 }
 565
 566
 567 /*
 568  * adfWriteDirCblock
 569  *
 570  */
 571 RETCODE adfWriteDirCBlock(struct Volume* vol, ULONG nSect, struct bDirCacheBlock* dirc)
 572 {
 573     unsigned char buf[LOGICAL_BLOCK_SIZE];
 574     ULONG newSum;
 575
 576     dirc->type = T_DIRC;
 577     dirc->headerKey = nSect;
 578
 579     memcpy(buf, dirc, LOGICAL_BLOCK_SIZE);
 580 #ifdef LITT_ENDIAN
 581     swapEndian(buf, SWBL_CACHE);
 582 #endif
 583
 584     newSum = adfNormalSum(buf, 20, LOGICAL_BLOCK_SIZE);
 585     swLong(buf+20,newSum);
 586 //    *(ULONG*)(buf+20) = swapLong((unsigned char*)&newSum);
 587
 588     if (adfWriteBlock(vol, nSect, buf)!=RC_OK)
 589                 return RC_ERROR;
 590 //puts("adfWriteDirCBlock");
 591
 592     return RC_OK;
 593 }
 594
 595 /*################################################################################*/