tools/adflib/adf_salv.c

   1 /*
   2  *  ADF Library. (C) 1997-1999 Laurent Clevy
   3  *
   4  *  adf_salv.c
   5  *
   6  */
   7
   8 #include<string.h>
   9 #include<stdlib.h>
  10
  11 #include "adf_salv.h"
  12 #include "adf_bitm.h"
  13 #include "adf_util.h"
  14 #include "adf_disk.h"
  15 #include "adf_dir.h"
  16 #include "adf_file.h"
  17 #include "adf_cache.h"
  18
  19 extern struct Env adfEnv;
  20
  21 /*
  22  * adfFreeGenBlock
  23  *
  24  */
  25 void adfFreeGenBlock(struct GenBlock* block)
  26 {
  27     if (block->name!=NULL)
  28         free(block->name);
  29 }
  30
  31
  32 /*
  33  * adfFreeDelList
  34  *
  35  */
  36 void adfFreeDelList(struct List* list)
  37 {
  38     struct List *cell;
  39
  40     cell = list;
  41     while(cell!=NULL) {
  42         adfFreeGenBlock((struct GenBlock*)cell->content);
  43         cell = cell->next;
  44     }
  45     freeList(list);
  46 }
  47
  48
  49 /*
  50  * adfGetDelEnt
  51  *
  52  */
  53 struct List* adfGetDelEnt(struct Volume *vol)
  54 {
  55     struct GenBlock *block;
  56     long i;
  57     struct List *list, *head;
  58     BOOL delEnt;
  59
  60     list = head = NULL;
  61     block = NULL;
  62     delEnt = TRUE;
  63     for(i=vol->firstBlock; i<=vol->lastBlock; i++) {
  64         if (adfIsBlockFree(vol, i)) {
  65             if (delEnt) {
  66                 block = (struct GenBlock*)malloc(sizeof(struct GenBlock));
  67                 if (!block) return NULL;
  68 //printf("%p\n",block);
  69             }
  70
  71             adfReadGenBlock(vol, i, block);
  72
  73             delEnt = (block->type==T_HEADER
  74                 && (block->secType==ST_DIR || block->secType==ST_FILE) );
  75
  76             if (delEnt) {
  77                 if (head==NULL)
  78                     list = head = newCell(NULL, (void*)block);
  79                 else
  80                     list = newCell(list, (void*)block);
  81             }
  82         }
  83     }
  84
  85     if (block!=NULL && list!=NULL && block!=list->content) {
  86         free(block);
  87 //        printf("%p\n",block);
  88     }
  89     return head;
  90 }
  91
  92
  93 /*
  94  * adfReadGenBlock
  95  *
  96  */
  97 RETCODE adfReadGenBlock(struct Volume *vol, SECTNUM nSect, struct GenBlock *block)
  98 {
  99         unsigned char buf[LOGICAL_BLOCK_SIZE];
 100     int len;
 101     char name[MAXNAMELEN+1];
 102
 103         if (adfReadBlock(vol, nSect, buf)!=RC_OK)
 104                 return RC_ERROR;
 105
 106     block->type =(int) swapLong(buf);
 107     block->secType =(int) swapLong(buf+vol->blockSize-4);
 108     block->sect = nSect;
 109     block->name = NULL;
 110
 111     if (block->type==T_HEADER) {
 112         switch(block->secType) {
 113         case ST_FILE:
 114         case ST_DIR:
 115         case ST_LFILE:
 116         case ST_LDIR:
 117             len = min(MAXNAMELEN, buf[vol->blockSize-80]);
 118             strncpy(name, buf+vol->blockSize-79, len);
 119             name[len] = '\0';
 120             block->name = strdup(name);
 121             block->parent = swapLong(buf+vol->blockSize-12);
 122             break;
 123         case ST_ROOT:
 124             break;
 125         default:
 126             ;
 127         }
 128     }
 129     return RC_OK;
 130 }
 131
 132
 133 /*
 134  * adfCheckParent
 135  *
 136  */
 137 RETCODE adfCheckParent(struct Volume* vol, SECTNUM pSect)
 138 {
 139     struct GenBlock block;
 140
 141     if (adfIsBlockFree(vol, pSect)) {
 142         (*adfEnv.wFct)("adfCheckParent : parent doesn't exists");
 143         return RC_ERROR;
 144     }
 145
 146     /* verify if parent is a DIR or ROOT */
 147     adfReadGenBlock(vol, pSect, &block);
 148     if ( block.type!=T_HEADER
 149         || (block.secType!=ST_DIR && block.secType!=ST_ROOT) ) {
 150         (*adfEnv.wFct)("adfCheckParent : parent secType is incorrect");
 151         return RC_ERROR;
 152     }
 153
 154     return RC_OK;
 155 }
 156
 157
 158 /*
 159  * adfUndelDir
 160  *
 161  */
 162 RETCODE adfUndelDir(struct Volume* vol, SECTNUM pSect, SECTNUM nSect,
 163     struct bDirBlock* entry)
 164 {
 165     RETCODE rc;
 166     struct bEntryBlock parent;
 167     char name[MAXNAMELEN+1];
 168
 169     /* check if the given parent sector pointer seems OK */
 170     if ( (rc=adfCheckParent(vol,pSect)) != RC_OK)
 171         return rc;
 172
 173     if (pSect!=entry->parent) {
 174         (*adfEnv.wFct)("adfUndelDir : the given parent sector isn't the entry parent");
 175         return RC_ERROR;
 176     }
 177
 178     if (!adfIsBlockFree(vol, entry->headerKey))
 179         return RC_ERROR;
 180     if (isDIRCACHE(vol->dosType) && !adfIsBlockFree(vol,entry->extension))
 181         return RC_ERROR;
 182
 183     if (adfReadEntryBlock(vol, pSect, &parent)!=RC_OK)
 184                 return RC_ERROR;
 185
 186     strncpy(name, entry->dirName, entry->nameLen);
 187     name[(int)entry->nameLen] = '\0';
 188     /* insert the entry in the parent hashTable, with the headerKey sector pointer */
 189     adfSetBlockUsed(vol,entry->headerKey);
 190     adfCreateEntry(vol, &parent, name, entry->headerKey);
 191
 192     if (isDIRCACHE(vol->dosType)) {
 193         adfAddInCache(vol, &parent, (struct bEntryBlock *)entry);
 194         adfSetBlockUsed(vol,entry->extension);
 195     }
 196
 197     adfUpdateBitmap(vol);
 198
 199     return RC_OK;
 200 }
 201
 202
 203 /*
 204  * adfUndelFile
 205  *
 206  */
 207 RETCODE adfUndelFile(struct Volume* vol, SECTNUM pSect, SECTNUM nSect, struct bFileHeaderBlock* entry)
 208 {
 209     long i;
 210     char name[MAXNAMELEN+1];
 211     struct bEntryBlock parent;
 212     RETCODE rc;
 213     struct FileBlocks fileBlocks;
 214
 215     /* check if the given parent sector pointer seems OK */
 216     if ( (rc=adfCheckParent(vol,pSect)) != RC_OK)
 217         return rc;
 218
 219     if (pSect!=entry->parent) {
 220         (*adfEnv.wFct)("adfUndelFile : the given parent sector isn't the entry parent");
 221         return RC_ERROR;
 222     }
 223
 224     adfGetFileBlocks(vol, entry, &fileBlocks);
 225
 226     for(i=0; i<fileBlocks.nbData; i++)
 227         if ( !adfIsBlockFree(vol,fileBlocks.data[i]) )
 228             return RC_ERROR;
 229         else
 230             adfSetBlockUsed(vol, fileBlocks.data[i]);
 231     for(i=0; i<fileBlocks.nbExtens; i++)
 232         if ( !adfIsBlockFree(vol,fileBlocks.extens[i]) )
 233             return RC_ERROR;
 234         else
 235             adfSetBlockUsed(vol, fileBlocks.extens[i]);
 236
 237     free(fileBlocks.data);
 238     free(fileBlocks.extens);
 239
 240     if (adfReadEntryBlock(vol, pSect, &parent)!=RC_OK)
 241                 return RC_ERROR;
 242
 243     strncpy(name, entry->fileName, entry->nameLen);
 244     name[(int)entry->nameLen] = '\0';
 245     /* insert the entry in the parent hashTable, with the headerKey sector pointer */
 246     adfCreateEntry(vol, &parent, name, entry->headerKey);
 247
 248     if (isDIRCACHE(vol->dosType))
 249         adfAddInCache(vol, &parent, (struct bEntryBlock *)entry);
 250
 251     adfUpdateBitmap(vol);
 252
 253     return RC_OK;
 254 }
 255
 256
 257 /*
 258  * adfUndelEntry
 259  *
 260  */
 261 RETCODE adfUndelEntry(struct Volume* vol, SECTNUM parent, SECTNUM nSect)
 262 {
 263     struct bEntryBlock entry;
 264
 265     adfReadEntryBlock(vol,nSect,&entry);
 266
 267     switch(entry.secType) {
 268     case ST_FILE:
 269         adfUndelFile(vol, parent, nSect, (struct bFileHeaderBlock*)&entry);
 270         break;
 271     case ST_DIR:
 272         adfUndelDir(vol, parent, nSect, (struct bDirBlock*)&entry);
 273         break;
 274     default:
 275         ;
 276     }
 277
 278     return RC_OK;
 279 }
 280
 281
 282 /*
 283  * adfCheckFile
 284  *
 285  */
 286 RETCODE adfCheckFile(struct Volume* vol, SECTNUM nSect,
 287     struct bFileHeaderBlock* file, int level)
 288 {
 289     struct bFileExtBlock extBlock;
 290     struct bOFSDataBlock dataBlock;
 291     struct FileBlocks fileBlocks;
 292     int n;
 293
 294     adfGetFileBlocks(vol,file,&fileBlocks);
 295 //printf("data %ld ext %ld\n",fileBlocks.nbData,fileBlocks.nbExtens);
 296     if (isOFS(vol->dosType)) {
 297         /* checks OFS datablocks */
 298         for(n=0; n<fileBlocks.nbData; n++) {
 299 //printf("%ld\n",fileBlocks.data[n]);
 300             adfReadDataBlock(vol,fileBlocks.data[n],&dataBlock);
 301             if (dataBlock.headerKey!=fileBlocks.header)
 302                 (*adfEnv.wFct)("adfCheckFile : headerKey incorrect");
 303             if (dataBlock.seqNum!=n+1)
 304                 (*adfEnv.wFct)("adfCheckFile : seqNum incorrect");
 305             if (n<fileBlocks.nbData-1) {
 306                 if (dataBlock.nextData!=fileBlocks.data[n+1])
 307                     (*adfEnv.wFct)("adfCheckFile : nextData incorrect");
 308                 if (dataBlock.dataSize!=vol->datablockSize)
 309                     (*adfEnv.wFct)("adfCheckFile : dataSize incorrect");
 310             }
 311             else { /* last datablock */
 312                 if (dataBlock.nextData!=0)
 313                     (*adfEnv.wFct)("adfCheckFile : nextData incorrect");
 314             }
 315         }
 316     }
 317     for(n=0; n<fileBlocks.nbExtens; n++) {
 318         adfReadFileExtBlock(vol,fileBlocks.extens[n],&extBlock);
 319         if (extBlock.parent!=file->headerKey)
 320             (*adfEnv.wFct)("adfCheckFile : extBlock parent incorrect");
 321         if (n<fileBlocks.nbExtens-1) {
 322             if (extBlock.extension!=fileBlocks.extens[n+1])
 323                 (*adfEnv.wFct)("adfCheckFile : nextData incorrect");
 324         }
 325         else
 326             if (extBlock.extension!=0)
 327                 (*adfEnv.wFct)("adfCheckFile : nextData incorrect");
 328     }
 329
 330     free(fileBlocks.data);
 331     free(fileBlocks.extens);
 332
 333     return RC_OK;
 334 }
 335
 336
 337 /*
 338  * adfCheckDir
 339  *
 340  */
 341 RETCODE adfCheckDir(struct Volume* vol, SECTNUM nSect, struct bDirBlock* dir,
 342     int level)
 343 {
 344
 345
 346
 347
 348     return RC_OK;
 349 }
 350
 351
 352 /*
 353  * adfCheckEntry
 354  *
 355  */
 356 RETCODE adfCheckEntry(struct Volume* vol, SECTNUM nSect, int level)
 357 {
 358     struct bEntryBlock entry;
 359     RETCODE rc;
 360
 361     adfReadEntryBlock(vol,nSect,&entry);
 362
 363     switch(entry.secType) {
 364     case ST_FILE:
 365         rc = adfCheckFile(vol, nSect, (struct bFileHeaderBlock*)&entry, level);
 366         break;
 367     case ST_DIR:
 368         rc = adfCheckDir(vol, nSect, (struct bDirBlock*)&entry, level);
 369         break;
 370     default:
 371         printf("adfCheckEntry : not supported\n");
 372         rc = RC_ERROR;
 373     }
 374
 375     return rc;
 376 }
 377
 378
 379 /*#############################################################################*/