tools/adflib/adf_raw.c

   1 /*
   2  *  ADF Library. (C) 1997-1998 Laurent Clevy
   3  *
   4  *  adf_raw.c
   5  *
   6  * logical disk/volume code
   7  */
   8
   9 #include <stdio.h>
  10 #include <limits.h>
  11 #include <stdlib.h>
  12 #include <string.h>
  13
  14 #include "adf_str.h"
  15 #include "adf_raw.h"
  16 #include "adf_blk.h"
  17 #include "adf_disk.h"
  18 #include "adf_util.h"
  19 #include "adf_err.h"
  20 #include "defendian.h"
  21
  22 extern struct Env adfEnv;
  23
  24 int swapTable[MAX_SWTYPE+1][15]={
  25     { 4, SW_CHAR, 2, SW_LONG, 1012, SW_CHAR, 0, 1024 },     /* first bytes of boot */
  26     { 108, SW_LONG, 40, SW_CHAR, 10, SW_LONG, 0, 512 },        /* root */
  27     { 6, SW_LONG, 488, SW_CHAR, 0, 512 },                      /* data */
  28                                                             /* file, dir, entry */
  29     { 82, SW_LONG, 92, SW_CHAR, 3, SW_LONG, 36, SW_CHAR, 11, SW_LONG, 0, 512 },
  30     { 6, SW_LONG, 0, 24 },                                       /* cache */
  31     { 128, SW_LONG, 0, 512 },                                /* bitmap, fext */
  32                                                                     /* link */
  33     { 6, SW_LONG, 64, SW_CHAR, 86, SW_LONG, 32, SW_CHAR, 12, SW_LONG, 0, 512 },
  34     { 4, SW_CHAR, 39, SW_LONG, 56, SW_CHAR, 10, SW_LONG, 0, 256 }, /* RDSK */
  35     { 4, SW_CHAR, 127, SW_LONG, 0, 512 },                          /* BADB */
  36     { 4, SW_CHAR, 8, SW_LONG, 32, SW_CHAR, 31, SW_LONG, 4, SW_CHAR, /* PART */
  37       15, SW_LONG, 0, 256 },
  38     { 4, SW_CHAR, 7, SW_LONG, 4, SW_CHAR, 55, SW_LONG, 0, 256 }, /* FSHD */
  39     { 4, SW_CHAR, 4, SW_LONG, 492, SW_CHAR, 0, 512 },            /* LSEG */
  40     { 4, SW_CHAR, 4, SW_LONG, 492, SW_CHAR, 0, 512 }             /* BOOT */
  41     };
  42
  43
  44 /*
  45  * swapEndian
  46  *
  47  * magic :-) endian swap function (big -> little for read, little to big for write)
  48  */
  49
  50     void
  51 swapEndian( UBYTE *buf, int type )
  52 {
  53     int i,j;
  54     int p;
  55
  56     i=0;
  57     p=0;
  58
  59     if (type>MAX_SWTYPE || type<0)
  60         adfEnv.eFct("SwapEndian: type do not exist");
  61
  62     while( swapTable[type][i]!=0 ) {
  63         for(j=0; j<swapTable[type][i]; j++) {
  64             switch( swapTable[type][i+1] ) {
  65             case SW_LONG:
  66                 *(ULONG*)(buf+p)=Long(buf+p);
  67                 p+=4;
  68                 break;
  69             case SW_SHORT:
  70                 *(USHORT*)(buf+p)=Short(buf+p);
  71                 p+=2;
  72                 break;
  73             case SW_CHAR:
  74                 p++;
  75                 break;
  76             default:
  77                 ;
  78             }
  79         }
  80     i+=2;
  81     }
  82     if (p!=swapTable[type][i+1])
  83         (*adfEnv.wFct)("Warning: Endian Swapping length\n");
  84
  85
  86 }
  87
  88
  89
  90
  91
  92 /*
  93  * adfReadRootBlock
  94  *
  95  * ENDIAN DEPENDENT
  96  */
  97 RETCODE
  98 adfReadRootBlock(struct Volume* vol, ULONG nSect, struct bRootBlock* root)
  99 {
 100         unsigned char buf[LOGICAL_BLOCK_SIZE];
 101
 102         if (adfReadBlock(vol, nSect, buf)!=RC_OK)
 103                 return RC_ERROR;
 104
 105         memcpy(root, buf, LOGICAL_BLOCK_SIZE);
 106 #ifdef LITT_ENDIAN
 107     swapEndian((unsigned char*)root, SWBL_ROOT);
 108 #endif
 109
 110         if (root->type!=T_HEADER || root->secType!=ST_ROOT) {
 111                 (*adfEnv.wFct)("adfReadRootBlock : id not found");
 112         return RC_ERROR;
 113     }
 114         if (root->checkSum!=adfNormalSum(buf, 20, LOGICAL_BLOCK_SIZE)) {
 115                 (*adfEnv.wFct)("adfReadRootBlock : invalid checksum");
 116         return RC_ERROR;
 117     }
 118
 119     return RC_OK;
 120 }
 121
 122
 123 /*
 124  * adfWriteRootBlock
 125  *
 126  *
 127  */
 128 RETCODE adfWriteRootBlock(struct Volume* vol, ULONG nSect, struct bRootBlock* root)
 129 {
 130     unsigned char buf[LOGICAL_BLOCK_SIZE];
 131         ULONG newSum;
 132
 133
 134     root->type = T_HEADER;
 135     root->headerKey = 0L;
 136     root->highSeq = 0L;
 137     root->hashTableSize = HT_SIZE;
 138     root->firstData = 0L;
 139     /* checkSum, hashTable */
 140     /* bmflag */
 141     /* bmPages, bmExt */
 142     root->nextSameHash = 0L;
 143     root->parent = 0L;
 144     root->secType = ST_ROOT;
 145
 146     memcpy(buf, root, LOGICAL_BLOCK_SIZE);
 147
 148 #ifdef LITT_ENDIAN
 149     swapEndian(buf, SWBL_ROOT);
 150 #endif
 151
 152     newSum = adfNormalSum(buf,20,LOGICAL_BLOCK_SIZE);
 153     swLong(buf+20, newSum);
 154
 155 // dumpBlock(buf);
 156     if (adfWriteBlock(vol, nSect, buf)!=RC_OK)
 157         return RC_ERROR;
 158 //printf("adfWriteRootBlock %ld\n",nSect);
 159     return RC_OK;
 160 }
 161
 162
 163 /*
 164  * adfReadBootBlock
 165  *
 166  * ENDIAN DEPENDENT
 167  */
 168 RETCODE
 169 adfReadBootBlock(struct Volume* vol, struct bBootBlock* boot)
 170 {
 171         unsigned char buf[1024];
 172
 173 //puts("22");
 174         if (adfReadBlock(vol, 0, buf)!=RC_OK)
 175                 return RC_ERROR;
 176 //puts("11");
 177     if (adfReadBlock(vol, 1, buf+LOGICAL_BLOCK_SIZE)!=RC_OK)
 178                 return RC_ERROR;
 179
 180     memcpy(boot, buf, LOGICAL_BLOCK_SIZE*2);
 181 #ifdef LITT_ENDIAN
 182     swapEndian((unsigned char*)boot,SWBL_BOOTBLOCK);
 183 #endif
 184         if ( strncmp("DOS",boot->dosType,3)!=0 ) {
 185                 (*adfEnv.wFct)("adfReadBootBlock : DOS id not found");
 186                 return RC_ERROR;
 187     }
 188
 189         if ( boot->data[0]!=0 && adfBootSum(buf)!=boot->checkSum ) {
 190 printf("compsum=%lx sum=%lx\n", (long)adfBootSum(buf),(long)boot->checkSum );
 191                 (*adfEnv.wFct)("adfReadBootBlock : incorrect checksum");
 192     }
 193
 194     return RC_OK;
 195 }
 196
 197 /*
 198  * adfWriteBootBlock
 199  *
 200  *
 201  *     write bootcode ?
 202  */
 203 RETCODE
 204 adfWriteBootBlock(struct Volume* vol, struct bBootBlock* boot)
 205 {
 206     unsigned char buf[LOGICAL_BLOCK_SIZE*2];
 207         ULONG newSum;
 208
 209     boot->dosType[0] = 'D';
 210     boot->dosType[1] = 'O';
 211     boot->dosType[2] = 'S';
 212     boot->dosType[3] = vol->dosType;
 213
 214     boot->rootBlock = vol->rootBlock;
 215
 216     memcpy(buf, boot, LOGICAL_BLOCK_SIZE*2);
 217 #ifdef LITT_ENDIAN
 218     swapEndian(buf, SWBL_BOOTBLOCK);
 219 #endif
 220
 221     if (boot->rootBlock==880 || boot->data[0]!=0) {
 222         newSum = adfBootSum(buf);
 223 //fprintf(stderr,"sum %x %x\n",newSum,adfBootSum2(buf));
 224         swLong(buf+4,newSum);
 225 //        *(ULONG*)(buf+4) = swapLong((unsigned char*)&newSum);
 226     }
 227
 228 /*      dumpBlock(buf);
 229         dumpBlock(buf+512);
 230 */
 231     if (adfWriteBlock(vol, 0, buf)!=RC_OK)
 232                 return RC_ERROR;
 233         if (adfWriteBlock(vol, 1,  buf+512)!=RC_OK)
 234                 return RC_ERROR;
 235 //puts("adfWriteBootBlock");
 236     return RC_OK;
 237 }
 238
 239
 240 /*
 241  * NormalSum
 242  *
 243  * buf = where the block is stored
 244  * offset = checksum place (in bytes)
 245  * bufLen = buffer length (in bytes)
 246  */
 247     ULONG
 248 adfNormalSum( UCHAR* buf, int offset, int bufLen )
 249 {
 250     ULONG newsum;
 251     int i;
 252
 253     newsum=0L;
 254     for(i=0; i < (bufLen/4); i++)
 255         if ( i != (offset/4) )       /* old chksum */
 256             newsum+=Long(buf+i*4);
 257     newsum=(-newsum);   /* WARNING */
 258
 259     return(newsum);
 260 }
 261
 262 /*
 263  * adfBitmapSum
 264  *
 265  */
 266         ULONG
 267 adfBitmapSum(unsigned char *buf)
 268 {
 269         ULONG newSum;
 270         int i;
 271
 272         newSum = 0L;
 273         for(i=1; i<128; i++)
 274                 newSum-=Long(buf+i*4);
 275         return(newSum);
 276 }
 277
 278
 279 /*
 280  * adfBootSum
 281  *
 282  */
 283     ULONG
 284 adfBootSum(unsigned char *buf)
 285 {
 286     ULONG d, newSum;
 287     int i;
 288
 289     newSum=0L;
 290     for(i=0; i<256; i++) {
 291         if (i!=1) {
 292             d = Long(buf+i*4);
 293             if ( (ULONG_MAX-newSum)<d )
 294                 newSum++;
 295             newSum+=d;
 296         }
 297     }
 298     newSum = ~newSum;   /* not */
 299
 300     return(newSum);
 301 }
 302
 303     ULONG
 304 adfBootSum2(unsigned char *buf)
 305 {
 306     ULONG prevsum, newSum;
 307     int i;
 308
 309     prevsum = newSum=0L;
 310     for(i=0; i<1024/sizeof(ULONG); i++) {
 311         if (i!=1) {
 312             prevsum = newSum;
 313             newSum += Long(buf+i*4);
 314             if (newSum < prevsum)
 315                 newSum++;
 316         }
 317     }
 318     newSum = ~newSum;   /* not */
 319
 320     return(newSum);
 321 }
 322
 323
 324 /*#######################################################################################*/