930 lines
21 KiB
C
Executable file
930 lines
21 KiB
C
Executable file
#include "sysincludes.h"
|
|
#include "msdos.h"
|
|
#include "stream.h"
|
|
#include "mtools.h"
|
|
#include "fsP.h"
|
|
|
|
extern Stream_t *default_drive;
|
|
|
|
#ifdef HAVE_LONG_LONG
|
|
typedef long long fatBitMask;
|
|
#else
|
|
typedef long fatBitMask;
|
|
#endif
|
|
|
|
typedef struct FatMap_t {
|
|
unsigned char *data;
|
|
fatBitMask dirty;
|
|
fatBitMask valid;
|
|
} FatMap_t;
|
|
|
|
#define SECT_PER_ENTRY (sizeof(fatBitMask)*8)
|
|
#define ONE ((fatBitMask) 1)
|
|
|
|
static inline int readSector(Fs_t *This, char *buf, unsigned int off,
|
|
size_t size)
|
|
{
|
|
return READS(This->Next, buf, sectorsToBytes((Stream_t *)This, off),
|
|
size << This->sectorShift);
|
|
}
|
|
|
|
|
|
static inline int forceReadSector(Fs_t *This, char *buf, unsigned int off,
|
|
size_t size)
|
|
{
|
|
return force_read(This->Next, buf, sectorsToBytes((Stream_t *)This, off),
|
|
size << This->sectorShift);
|
|
}
|
|
|
|
|
|
static inline int writeSector(Fs_t *This, char *buf, unsigned int off,
|
|
size_t size)
|
|
{
|
|
return WRITES(This->Next, buf, sectorsToBytes((Stream_t*)This, off),
|
|
size << This->sectorShift);
|
|
}
|
|
|
|
static inline int forceWriteSector(Fs_t *This, char *buf, unsigned int off,
|
|
size_t size)
|
|
{
|
|
return force_write(This->Next, buf, sectorsToBytes((Stream_t*)This, off),
|
|
size << This->sectorShift);
|
|
}
|
|
|
|
|
|
static FatMap_t *GetFatMap(Fs_t *Stream)
|
|
{
|
|
int nr_entries,i;
|
|
FatMap_t *map;
|
|
|
|
Stream->fat_error = 0;
|
|
nr_entries = (Stream->fat_len + SECT_PER_ENTRY - 1) / SECT_PER_ENTRY;
|
|
map = NewArray(nr_entries, FatMap_t);
|
|
if(!map)
|
|
return 0;
|
|
|
|
for(i=0; i< nr_entries; i++) {
|
|
map[i].data = 0;
|
|
map[i].valid = 0;
|
|
map[i].dirty = 0;
|
|
}
|
|
|
|
return map;
|
|
}
|
|
|
|
static inline int locate(Fs_t *Stream, int offset, int *slot, int *bit)
|
|
{
|
|
if(offset >= Stream->fat_len)
|
|
return -1;
|
|
*slot = offset / SECT_PER_ENTRY;
|
|
*bit = offset % SECT_PER_ENTRY;
|
|
return 0;
|
|
}
|
|
|
|
static inline int fatReadSector(Fs_t *This, int sector, int slot,
|
|
int bit, int dupe)
|
|
{
|
|
int fat_start, ret;
|
|
|
|
dupe = (dupe + This->primaryFat) % This->num_fat;
|
|
fat_start = This->fat_start + This->fat_len * dupe;
|
|
|
|
/* first, read as much as the buffer can give us */
|
|
ret = readSector(This,
|
|
(char *)(This->FatMap[slot].data+(bit<<This->sectorShift)),
|
|
fat_start+sector,
|
|
(SECT_PER_ENTRY - bit%SECT_PER_ENTRY));
|
|
if(ret < 0)
|
|
return 0;
|
|
|
|
if(ret < This->sector_size) {
|
|
/* if we got less than one sector's worth, insist to get at
|
|
* least one sector */
|
|
ret = forceReadSector(This,
|
|
(char *) (This->FatMap[slot].data +
|
|
(bit << This->sectorShift)),
|
|
fat_start+sector, 1);
|
|
if(ret < This->sector_size)
|
|
return 0;
|
|
return 1;
|
|
}
|
|
|
|
return ret >> This->sectorShift;
|
|
}
|
|
|
|
|
|
static int fatWriteSector(Fs_t *This, int sector, int slot, int bit, int dupe)
|
|
{
|
|
int fat_start;
|
|
|
|
dupe = (dupe + This->primaryFat) % This->num_fat;
|
|
if(dupe && !This->writeAllFats)
|
|
return This->sector_size;
|
|
|
|
fat_start = This->fat_start + This->fat_len * dupe;
|
|
|
|
return forceWriteSector(This,
|
|
(char *)
|
|
(This->FatMap[slot].data + bit * This->sector_size),
|
|
fat_start+sector, 1);
|
|
}
|
|
|
|
static unsigned char *loadSector(Fs_t *This,
|
|
unsigned int sector, fatAccessMode_t mode,
|
|
int recurs)
|
|
{
|
|
int slot, bit, i, ret;
|
|
|
|
if(locate(This,sector, &slot, &bit) < 0)
|
|
return 0;
|
|
#if 0
|
|
if (((This->fat_len + SECT_PER_ENTRY - 1) / SECT_PER_ENTRY) <= slot) {
|
|
fprintf(stderr,"This should not happen\n");
|
|
fprintf(stderr, "fat_len = %d\n", This->fat_len);
|
|
fprintf(stderr, "SECT_PER_ENTRY=%d\n", (int)SECT_PER_ENTRY);
|
|
fprintf(stderr, "sector = %d slot = %d bit=%d\n",
|
|
sector, slot, bit);
|
|
fprintf(stderr, "left = %d",(int)
|
|
((This->fat_len+SECT_PER_ENTRY-1) / SECT_PER_ENTRY));
|
|
return 0;
|
|
}
|
|
#endif
|
|
if(!This->FatMap[slot].data) {
|
|
/* allocate the storage space */
|
|
This->FatMap[slot].data =
|
|
malloc(This->sector_size * SECT_PER_ENTRY);
|
|
if(!This->FatMap[slot].data)
|
|
return 0;
|
|
memset(This->FatMap[slot].data, 0xee,
|
|
This->sector_size * SECT_PER_ENTRY);
|
|
}
|
|
|
|
if(! (This->FatMap[slot].valid & (ONE << bit))) {
|
|
ret = -1;
|
|
for(i=0; i< This->num_fat; i++) {
|
|
/* read the sector */
|
|
ret = fatReadSector(This, sector, slot, bit, i);
|
|
|
|
if(ret == 0) {
|
|
fprintf(stderr,
|
|
"Error reading fat number %d\n", i);
|
|
continue;
|
|
}
|
|
break;
|
|
}
|
|
|
|
/* all copies bad. Return error */
|
|
if(ret == 0)
|
|
return 0;
|
|
|
|
for(i=0; i < ret; i++)
|
|
This->FatMap[slot].valid |= ONE << (bit + i);
|
|
|
|
if(!recurs && ret == 1)
|
|
/* do some prefetching, if we happened to only
|
|
* get one sector */
|
|
loadSector(This, sector+1, mode, 1);
|
|
if(!recurs && batchmode)
|
|
for(i=0; i < 1024; i++)
|
|
loadSector(This, sector+i, mode, 1);
|
|
}
|
|
|
|
if(mode == FAT_ACCESS_WRITE) {
|
|
This->FatMap[slot].dirty |= ONE << bit;
|
|
This->fat_dirty = 1;
|
|
}
|
|
return This->FatMap[slot].data + (bit << This->sectorShift);
|
|
}
|
|
|
|
|
|
static unsigned char *getAddress(Fs_t *Stream,
|
|
unsigned int num, fatAccessMode_t mode)
|
|
{
|
|
unsigned char *ret;
|
|
int sector;
|
|
int offset;
|
|
|
|
sector = num >> Stream->sectorShift;
|
|
ret = 0;
|
|
if(sector == Stream->lastFatSectorNr &&
|
|
Stream->lastFatAccessMode >= mode)
|
|
ret = Stream->lastFatSectorData;
|
|
if(!ret) {
|
|
ret = loadSector(Stream, sector, mode, 0);
|
|
if(!ret)
|
|
return 0;
|
|
Stream->lastFatSectorNr = sector;
|
|
Stream->lastFatSectorData = ret;
|
|
Stream->lastFatAccessMode = mode;
|
|
}
|
|
offset = num & Stream->sectorMask;
|
|
return ret+offset;
|
|
}
|
|
|
|
|
|
static int readByte(Fs_t *Stream, int start)
|
|
{
|
|
unsigned char *address;
|
|
|
|
address = getAddress(Stream, start, FAT_ACCESS_READ);
|
|
if(!address)
|
|
return -1;
|
|
return *address;
|
|
}
|
|
|
|
|
|
/*
|
|
* Fat 12 encoding:
|
|
* | byte n | byte n+1 | byte n+2 |
|
|
* |7|6|5|4|3|2|1|0|7|6|5|4|3|2|1|0|7|6|5|4|3|2|1|0|
|
|
* | | | | | | | | | | | | | | | | | | | | | | | | |
|
|
* | n+0.0 | n+0.5 | n+1.0 | n+1.5 | n+2.0 | n+2.5 |
|
|
* \_____ \____ \______/________/_____ /
|
|
* ____\______\________/ _____/ ____\_/
|
|
* / \ \ / / \
|
|
* | n+1.5 | n+0.0 | n+0.5 | n+2.0 | n+2.5 | n+1.0 |
|
|
* | FAT entry k | FAT entry k+1 |
|
|
*/
|
|
|
|
/*
|
|
* Get and decode a FAT (file allocation table) entry. Returns the cluster
|
|
* number on success or 1 on failure.
|
|
*/
|
|
|
|
static unsigned int fat12_decode(Fs_t *Stream, unsigned int num)
|
|
{
|
|
unsigned int start = num * 3 / 2;
|
|
int byte0 = readByte(Stream, start);
|
|
int byte1 = readByte(Stream, start+1);
|
|
|
|
if (num < 2 || byte0 < 0 || byte1 < 0 || num > Stream->num_clus+1) {
|
|
fprintf(stderr,"[1] Bad address %d\n", num);
|
|
return 1;
|
|
}
|
|
|
|
if (num & 1)
|
|
return (byte1 << 4) | ((byte0 & 0xf0)>>4);
|
|
else
|
|
return ((byte1 & 0xf) << 8) | byte0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Puts a code into the FAT table. Is the opposite of fat_decode(). No
|
|
* sanity checking is done on the code. Returns a 1 on error.
|
|
*/
|
|
static void fat12_encode(Fs_t *Stream, unsigned int num, unsigned int code)
|
|
{
|
|
int start = num * 3 / 2;
|
|
unsigned char *address0 = getAddress(Stream, start, FAT_ACCESS_WRITE);
|
|
unsigned char *address1 = getAddress(Stream, start+1, FAT_ACCESS_WRITE);
|
|
|
|
if (num & 1) {
|
|
/* (odd) not on byte boundary */
|
|
*address0 = (*address0 & 0x0f) | ((code << 4) & 0xf0);
|
|
*address1 = (code >> 4) & 0xff;
|
|
} else {
|
|
/* (even) on byte boundary */
|
|
*address0 = code & 0xff;
|
|
*address1 = (*address1 & 0xf0) | ((code >> 8) & 0x0f);
|
|
}
|
|
}
|
|
|
|
|
|
/*
|
|
* Fat 16 encoding:
|
|
* | byte n | byte n+1 |
|
|
* |7|6|5|4|3|2|1|0|7|6|5|4|3|2|1|0|
|
|
* | | | | | | | | | | | | | | | | |
|
|
* | FAT entry k |
|
|
*/
|
|
|
|
static unsigned int fat16_decode(Fs_t *Stream, unsigned int num)
|
|
{
|
|
unsigned char *address = getAddress(Stream, num << 1, FAT_ACCESS_READ);
|
|
return _WORD(address);
|
|
}
|
|
|
|
static void fat16_encode(Fs_t *Stream, unsigned int num, unsigned int code)
|
|
{
|
|
unsigned char *address = getAddress(Stream, num << 1, FAT_ACCESS_WRITE);
|
|
set_word(address, code);
|
|
}
|
|
|
|
|
|
static unsigned int fast_fat16_decode(Fs_t *Stream, unsigned int num)
|
|
{
|
|
unsigned short *address =
|
|
(unsigned short *) getAddress(Stream, num << 1,
|
|
FAT_ACCESS_READ);
|
|
return *address;
|
|
}
|
|
|
|
static void fast_fat16_encode(Fs_t *Stream, unsigned int num, unsigned int code)
|
|
{
|
|
unsigned short *address =
|
|
(unsigned short *) getAddress(Stream, num << 1,
|
|
FAT_ACCESS_WRITE);
|
|
*address = code;
|
|
}
|
|
|
|
|
|
|
|
|
|
/*
|
|
* Fat 32 encoding
|
|
*/
|
|
static unsigned int fat32_decode(Fs_t *Stream, unsigned int num)
|
|
{
|
|
unsigned char *address = getAddress(Stream, num << 2, FAT_ACCESS_READ);
|
|
return _DWORD(address);
|
|
}
|
|
|
|
static void fat32_encode(Fs_t *Stream, unsigned int num, unsigned int code)
|
|
{
|
|
unsigned char *address = getAddress(Stream, num << 2, FAT_ACCESS_WRITE);
|
|
set_dword(address, code);
|
|
}
|
|
|
|
|
|
static unsigned int fast_fat32_decode(Fs_t *Stream, unsigned int num)
|
|
{
|
|
unsigned int *address =
|
|
(unsigned int *) getAddress(Stream, num << 2,
|
|
FAT_ACCESS_READ);
|
|
return *address;
|
|
}
|
|
|
|
static void fast_fat32_encode(Fs_t *Stream, unsigned int num, unsigned int code)
|
|
{
|
|
unsigned int *address =
|
|
(unsigned int *) getAddress(Stream, num << 2,
|
|
FAT_ACCESS_WRITE);
|
|
*address = code;
|
|
}
|
|
|
|
|
|
/*
|
|
* Write the FAT table to the disk. Up to now the FAT manipulation has
|
|
* been done in memory. All errors are fatal. (Might not be too smart
|
|
* to wait till the end of the program to write the table. Oh well...)
|
|
*/
|
|
|
|
void fat_write(Fs_t *This)
|
|
{
|
|
int i, j, dups, ret, bit, slot;
|
|
int fat_start;
|
|
|
|
/*fprintf(stderr, "Fat write\n");*/
|
|
|
|
if (!This->fat_dirty)
|
|
return;
|
|
|
|
dups = This->num_fat;
|
|
if (This->fat_error)
|
|
dups = 1;
|
|
|
|
|
|
for(i=0; i<dups; i++){
|
|
j = 0;
|
|
fat_start = This->fat_start + i*This->fat_len;
|
|
for(slot=0;j<This->fat_len;slot++) {
|
|
if(!This->FatMap[slot].dirty) {
|
|
j += SECT_PER_ENTRY;
|
|
continue;
|
|
}
|
|
for(bit=0;
|
|
bit < SECT_PER_ENTRY && j<This->fat_len;
|
|
bit++,j++) {
|
|
if(!(This->FatMap[slot].dirty & (ONE << bit)))
|
|
continue;
|
|
ret = fatWriteSector(This,j,slot, bit, i);
|
|
if (ret < This->sector_size){
|
|
if (ret < 0 ){
|
|
perror("error in fat_write");
|
|
exit(1);
|
|
} else {
|
|
fprintf(stderr,
|
|
"end of file in fat_write\n");
|
|
exit(1);
|
|
}
|
|
}
|
|
/* if last dupe, zero it out */
|
|
if(i==dups-1)
|
|
This->FatMap[slot].dirty &= ~(1<<bit);
|
|
}
|
|
}
|
|
}
|
|
/* write the info sector, if any */
|
|
if(This->infoSectorLoc && This->infoSectorLoc != MAX32) {
|
|
/* initialize info sector */
|
|
InfoSector_t *infoSector;
|
|
infoSector = (InfoSector_t *) safe_malloc(This->sector_size);
|
|
set_dword(infoSector->signature1, INFOSECT_SIGNATURE1);
|
|
memset(infoSector->filler1, sizeof(infoSector->filler1),0);
|
|
memset(infoSector->filler2, sizeof(infoSector->filler2),0);
|
|
set_dword(infoSector->signature2, INFOSECT_SIGNATURE2);
|
|
set_dword(infoSector->pos, This->last);
|
|
set_dword(infoSector->count, This->freeSpace);
|
|
set_dword(infoSector->signature3, 0xaa55);
|
|
if(forceWriteSector(This, (char *)infoSector, This->infoSectorLoc, 1) !=
|
|
This->sector_size)
|
|
fprintf(stderr,"Trouble writing the info sector\n");
|
|
free(infoSector);
|
|
}
|
|
This->fat_dirty = 0;
|
|
This->lastFatAccessMode = FAT_ACCESS_READ;
|
|
}
|
|
|
|
|
|
|
|
/*
|
|
* Zero-Fat
|
|
* Used by mformat.
|
|
*/
|
|
int zero_fat(Fs_t *Stream, int media_descriptor)
|
|
{
|
|
int i, j;
|
|
int fat_start;
|
|
unsigned char *buf;
|
|
|
|
buf = malloc(Stream->sector_size);
|
|
if(!buf) {
|
|
perror("alloc fat sector buffer");
|
|
return -1;
|
|
}
|
|
for(i=0; i< Stream->num_fat; i++) {
|
|
fat_start = Stream->fat_start + i*Stream->fat_len;
|
|
for(j = 0; j < Stream->fat_len; j++) {
|
|
if(j <= 1)
|
|
memset(buf, 0, Stream->sector_size);
|
|
if(!j) {
|
|
buf[0] = media_descriptor;
|
|
buf[2] = buf[1] = 0xff;
|
|
if(Stream->fat_bits > 12)
|
|
buf[3] = 0xff;
|
|
if(Stream->fat_bits > 16) {
|
|
buf[4] = 0xff;
|
|
buf[5] = 0xff;
|
|
buf[6] = 0xff;
|
|
buf[7] = 0x0f;
|
|
}
|
|
}
|
|
|
|
if(forceWriteSector(Stream, (char *)buf,
|
|
fat_start + j, 1) !=
|
|
Stream->sector_size) {
|
|
fprintf(stderr,
|
|
"Trouble initializing a FAT sector\n");
|
|
free(buf);
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
free(buf);
|
|
Stream->FatMap = GetFatMap(Stream);
|
|
if (Stream->FatMap == NULL) {
|
|
perror("alloc fat map");
|
|
return -1;
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
void set_fat12(Fs_t *This)
|
|
{
|
|
This->fat_bits = 12;
|
|
This->end_fat = 0xfff;
|
|
This->last_fat = 0xff6;
|
|
This->fat_decode = fat12_decode;
|
|
This->fat_encode = fat12_encode;
|
|
}
|
|
|
|
static char word_endian_test[] = { 0x34, 0x12 };
|
|
|
|
void set_fat16(Fs_t *This)
|
|
{
|
|
This->fat_bits = 16;
|
|
This->end_fat = 0xffff;
|
|
This->last_fat = 0xfff6;
|
|
|
|
if(sizeof(unsigned short) == 2 &&
|
|
* (unsigned short *) word_endian_test == 0x1234) {
|
|
This->fat_decode = fast_fat16_decode;
|
|
This->fat_encode = fast_fat16_encode;
|
|
} else {
|
|
This->fat_decode = fat16_decode;
|
|
This->fat_encode = fat16_encode;
|
|
}
|
|
}
|
|
|
|
static char dword_endian_test[] = { 0x78, 0x56, 0x34, 0x12 };
|
|
|
|
void set_fat32(Fs_t *This)
|
|
{
|
|
This->fat_bits = 32;
|
|
This->end_fat = 0xfffffff;
|
|
This->last_fat = 0xffffff6;
|
|
|
|
if(sizeof(unsigned int) == 4 &&
|
|
* (unsigned int *) dword_endian_test == 0x12345678) {
|
|
This->fat_decode = fast_fat32_decode;
|
|
This->fat_encode = fast_fat32_encode;
|
|
} else {
|
|
This->fat_decode = fat32_decode;
|
|
This->fat_encode = fat32_encode;
|
|
}
|
|
}
|
|
|
|
|
|
static int check_fat(Fs_t *This)
|
|
{
|
|
/*
|
|
* This is only a sanity check. For disks with really big FATs,
|
|
* there is no point in checking the whole FAT.
|
|
*/
|
|
|
|
int i, f, tocheck;
|
|
if(mtools_skip_check)
|
|
return 0;
|
|
|
|
/* too few sectors in the FAT */
|
|
if(This->fat_len < NEEDED_FAT_SIZE(This))
|
|
return -1;
|
|
/* we do not warn about too much sectors in FAT, which may
|
|
* happen when a partition has been shrunk using FIPS, or on
|
|
* other occurrences */
|
|
|
|
tocheck = This->num_clus;
|
|
if (tocheck < 0 || tocheck + 1 >= This->last_fat) {
|
|
fprintf(stderr, "Too many clusters in FAT\n");
|
|
return -1;
|
|
}
|
|
|
|
if(tocheck > 4096)
|
|
tocheck = 4096;
|
|
|
|
for ( i= 3 ; i < tocheck; i++){
|
|
f = This->fat_decode(This,i);
|
|
if (f == 1 || (f < This->last_fat && f > This->num_clus)){
|
|
fprintf(stderr,
|
|
"Cluster # at %d too big(%#x)\n", i,f);
|
|
fprintf(stderr,"Probably non MS-DOS disk\n");
|
|
return -1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Read the first sector of FAT table into memory. Crude error detection on
|
|
* wrong FAT encoding scheme.
|
|
*/
|
|
static int check_media_type(Fs_t *This, struct bootsector *boot,
|
|
unsigned int tot_sectors)
|
|
{
|
|
unsigned char *address;
|
|
|
|
This->num_clus = (tot_sectors - This->clus_start) / This->cluster_size;
|
|
|
|
This->FatMap = GetFatMap(This);
|
|
if (This->FatMap == NULL) {
|
|
perror("alloc fat map");
|
|
return -1;
|
|
}
|
|
|
|
address = getAddress(This, 0, FAT_ACCESS_READ);
|
|
if(!address) {
|
|
fprintf(stderr,
|
|
"Could not read first FAT sector\n");
|
|
return -1;
|
|
}
|
|
|
|
if(mtools_skip_check)
|
|
return 0;
|
|
|
|
if(!address[0] && !address[1] && !address[2])
|
|
/* Some Atari disks have zeroes where Dos has media descriptor
|
|
* and 0xff. Do not consider this as an error */
|
|
return 0;
|
|
|
|
if((address[0] != boot->descr && boot->descr >= 0xf0 &&
|
|
((address[0] != 0xf9 && address[0] != 0xf7)
|
|
|| boot->descr != 0xf0)) || address[0] < 0xf0) {
|
|
fprintf(stderr,
|
|
"Bad media types %02x/%02x, probably non-MSDOS disk\n",
|
|
address[0],
|
|
boot->descr);
|
|
return -1;
|
|
}
|
|
|
|
if(address[1] != 0xff || address[2] != 0xff){
|
|
fprintf(stderr,"Initial byte of fat is not 0xff\n");
|
|
return -1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static int fat_32_read(Fs_t *This, struct bootsector *boot,
|
|
unsigned int tot_sectors)
|
|
{
|
|
int size;
|
|
|
|
This->fat_len = DWORD(ext.fat32.bigFat);
|
|
This->writeAllFats = !(boot->ext.fat32.extFlags[0] & 0x80);
|
|
This->primaryFat = boot->ext.fat32.extFlags[0] & 0xf;
|
|
This->rootCluster = DWORD(ext.fat32.rootCluster);
|
|
This->clus_start = This->fat_start + This->num_fat * This->fat_len;
|
|
|
|
/* read the info sector */
|
|
size = This->sector_size;
|
|
This->infoSectorLoc = WORD(ext.fat32.infoSector);
|
|
if(This->sector_size >= 512 &&
|
|
This->infoSectorLoc && This->infoSectorLoc != MAX32) {
|
|
InfoSector_t *infoSector;
|
|
infoSector = (InfoSector_t *) safe_malloc(size);
|
|
if(forceReadSector(This, (char *)infoSector,
|
|
This->infoSectorLoc, 1) == This->sector_size &&
|
|
_DWORD(infoSector->signature1) == INFOSECT_SIGNATURE1 &&
|
|
_DWORD(infoSector->signature2) == INFOSECT_SIGNATURE2) {
|
|
This->freeSpace = _DWORD(infoSector->count);
|
|
This->last = _DWORD(infoSector->pos);
|
|
}
|
|
free(infoSector);
|
|
}
|
|
|
|
set_fat32(This);
|
|
return(check_media_type(This,boot, tot_sectors) ||
|
|
check_fat(This));
|
|
}
|
|
|
|
|
|
static int old_fat_read(Fs_t *This, struct bootsector *boot,
|
|
int config_fat_bits,
|
|
size_t tot_sectors, int nodups)
|
|
{
|
|
This->writeAllFats = 1;
|
|
This->primaryFat = 0;
|
|
This->dir_start = This->fat_start + This->num_fat * This->fat_len;
|
|
This->clus_start = This->dir_start + This->dir_len;
|
|
This->infoSectorLoc = MAX32;
|
|
|
|
if(nodups)
|
|
This->num_fat = 1;
|
|
|
|
if(check_media_type(This,boot, tot_sectors))
|
|
return -1;
|
|
|
|
if(This->num_clus > FAT12) {
|
|
set_fat16(This);
|
|
/* third FAT byte must be 0xff */
|
|
if(!mtools_skip_check && readByte(This, 3) != 0xff)
|
|
return -1;
|
|
} else
|
|
set_fat12(This);
|
|
|
|
return check_fat(This);
|
|
}
|
|
|
|
/*
|
|
* Read the first sector of the FAT table into memory and initialize
|
|
* structures.
|
|
*/
|
|
int fat_read(Fs_t *This, struct bootsector *boot, int fat_bits,
|
|
size_t tot_sectors, int nodups)
|
|
{
|
|
This->fat_error = 0;
|
|
This->fat_dirty = 0;
|
|
This->last = MAX32;
|
|
This->freeSpace = MAX32;
|
|
This->lastFatSectorNr = 0;
|
|
This->lastFatSectorData = 0;
|
|
|
|
if(This->fat_len)
|
|
return old_fat_read(This, boot, fat_bits, tot_sectors, nodups);
|
|
else
|
|
return fat_32_read(This, boot, tot_sectors);
|
|
}
|
|
|
|
|
|
unsigned int fatDecode(Fs_t *This, unsigned int pos)
|
|
{
|
|
int ret;
|
|
|
|
ret = This->fat_decode(This, pos);
|
|
if(ret && (ret < 2 || ret > This->num_clus+1) && ret < This->last_fat) {
|
|
fprintf(stderr, "Bad FAT entry %d at %d\n", ret, pos);
|
|
This->fat_error++;
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
/* append a new cluster */
|
|
void fatAppend(Fs_t *This, unsigned int pos, unsigned int newpos)
|
|
{
|
|
This->fat_encode(This, pos, newpos);
|
|
This->fat_encode(This, newpos, This->end_fat);
|
|
if(This->freeSpace != MAX32)
|
|
This->freeSpace--;
|
|
}
|
|
|
|
/* de-allocates the given cluster */
|
|
void fatDeallocate(Fs_t *This, unsigned int pos)
|
|
{
|
|
This->fat_encode(This, pos, 0);
|
|
if(This->freeSpace != MAX32)
|
|
This->freeSpace++;
|
|
}
|
|
|
|
/* allocate a new cluster */
|
|
void fatAllocate(Fs_t *This, unsigned int pos, unsigned int value)
|
|
{
|
|
This->fat_encode(This, pos, value);
|
|
if(This->freeSpace != MAX32)
|
|
This->freeSpace--;
|
|
}
|
|
|
|
void fatEncode(Fs_t *This, unsigned int pos, unsigned int value)
|
|
{
|
|
unsigned int oldvalue = This->fat_decode(This, pos);
|
|
This->fat_encode(This, pos, value);
|
|
if(This->freeSpace != MAX32) {
|
|
if(oldvalue)
|
|
This->freeSpace++;
|
|
if(value)
|
|
This->freeSpace--;
|
|
}
|
|
}
|
|
|
|
unsigned int get_next_free_cluster(Fs_t *This, unsigned int last)
|
|
{
|
|
int i;
|
|
|
|
if(This->last != MAX32)
|
|
last = This->last;
|
|
|
|
if (last < 2 ||
|
|
last >= This->num_clus+1)
|
|
last = 1;
|
|
|
|
for (i=last+1; i< This->num_clus+2; i++) {
|
|
if (!fatDecode(This, i)) {
|
|
This->last = i;
|
|
return i;
|
|
}
|
|
}
|
|
|
|
for(i=2; i < last+1; i++) {
|
|
if (!fatDecode(This, i)) {
|
|
This->last = i;
|
|
return i;
|
|
}
|
|
}
|
|
|
|
|
|
fprintf(stderr,"No free cluster %d %d\n", This->preallocatedClusters,
|
|
This->last);
|
|
return 1;
|
|
}
|
|
|
|
int fat_error(Stream_t *Dir)
|
|
{
|
|
Stream_t *Stream = GetFs(Dir);
|
|
DeclareThis(Fs_t);
|
|
|
|
if(This->fat_error)
|
|
fprintf(stderr,"Fat error detected\n");
|
|
|
|
return This->fat_error;
|
|
}
|
|
|
|
int fat32RootCluster(Stream_t *Dir)
|
|
{
|
|
Stream_t *Stream = GetFs(Dir);
|
|
DeclareThis(Fs_t);
|
|
|
|
if(This->fat_bits == 32)
|
|
return This->rootCluster;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
|
|
/*
|
|
* Get the amount of free space on the diskette
|
|
*/
|
|
|
|
mt_size_t getfree(Stream_t *Dir)
|
|
{
|
|
Stream_t *Stream = GetFs(Dir);
|
|
DeclareThis(Fs_t);
|
|
|
|
if(This->freeSpace == MAX32 || This->freeSpace == 0) {
|
|
register unsigned int i;
|
|
size_t total;
|
|
|
|
total = 0L;
|
|
for (i = 2; i < This->num_clus + 2; i++)
|
|
if (!fatDecode(This,i))
|
|
total++;
|
|
This->freeSpace = total;
|
|
}
|
|
return sectorsToBytes((Stream_t*)This,
|
|
This->freeSpace * This->cluster_size);
|
|
}
|
|
|
|
|
|
/*
|
|
* Ensure that there is a minimum of total sectors free
|
|
*/
|
|
int getfreeMinClusters(Stream_t *Dir, size_t size)
|
|
{
|
|
Stream_t *Stream = GetFs(Dir);
|
|
DeclareThis(Fs_t);
|
|
register unsigned int i, last;
|
|
size_t total;
|
|
|
|
if(batchmode && This->freeSpace == MAX32)
|
|
getfree(Stream);
|
|
|
|
if(This->freeSpace != MAX32) {
|
|
if(This->freeSpace >= size)
|
|
return 1;
|
|
else {
|
|
fprintf(stderr, "Disk full\n");
|
|
got_signal = 1;
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
total = 0L;
|
|
|
|
/* we start at the same place where we'll start later to actually
|
|
* allocate the sectors. That way, the same sectors of the FAT, which
|
|
* are already loaded during getfreeMin will be able to be reused
|
|
* during get_next_free_cluster */
|
|
last = This->last;
|
|
|
|
if ( last < 2 || last >= This->num_clus + 2)
|
|
last = 1;
|
|
for (i=last+1; i< This->num_clus+2; i++){
|
|
if (!fatDecode(This, i))
|
|
total++;
|
|
if(total >= size)
|
|
return 1;
|
|
}
|
|
for(i=2; i < last+1; i++){
|
|
if (!fatDecode(This, i))
|
|
total++;
|
|
if(total >= size)
|
|
return 1;
|
|
}
|
|
fprintf(stderr, "Disk full\n");
|
|
got_signal = 1;
|
|
return 0;
|
|
}
|
|
|
|
|
|
int getfreeMinBytes(Stream_t *Dir, mt_size_t size)
|
|
{
|
|
Stream_t *Stream = GetFs(Dir);
|
|
DeclareThis(Fs_t);
|
|
size_t size2;
|
|
|
|
size2 = size / (This->sector_size * This->cluster_size);
|
|
if(size % (This->sector_size * This->cluster_size))
|
|
size2++;
|
|
return getfreeMinClusters(Dir, size2);
|
|
}
|
|
|
|
|
|
unsigned int getStart(Stream_t *Dir, struct directory *dir)
|
|
{
|
|
Stream_t *Stream = GetFs(Dir);
|
|
unsigned int first;
|
|
|
|
first = START(dir);
|
|
if(fat32RootCluster(Stream))
|
|
first |= STARTHI(dir) << 16;
|
|
return first;
|
|
}
|
|
|
|
int fs_free(Stream_t *Stream)
|
|
{
|
|
DeclareThis(Fs_t);
|
|
|
|
if(This->FatMap) {
|
|
int i, nr_entries;
|
|
nr_entries = (This->fat_len + SECT_PER_ENTRY - 1) /
|
|
SECT_PER_ENTRY;
|
|
for(i=0; i< nr_entries; i++)
|
|
if(This->FatMap[i].data)
|
|
free(This->FatMap[i].data);
|
|
free(This->FatMap);
|
|
}
|
|
return 0;
|
|
}
|