os345p6.c

// os345p6.c - FAT File Management System
// ***********************************************************************
// **   DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER   **
// **                                                                   **
// ** The code given here is the basis for the CS345 projects.          **
// ** It comes "as is" and "unwarranted."  As such, when you use part   **
// ** or all of the code, it becomes "yours" and you are responsible to **
// ** understand any algorithm or method presented.  Likewise, any      **
// ** errors or problems become your responsibility to fix.             **
// **                                                                   **
// ** NOTES:                                                            **
// ** -Comments beginning with "// ??" may require some implementation. **
// ** -Tab stops are set at every 3 spaces.                             **
// ** -The function API's in "OS345.h" should not be altered.           **
// **                                                                   **
// **   DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER ** DISCLAMER   **
// ***********************************************************************
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <ctype.h>
#include <time.h>
#include <setjmp.h>
#include <assert.h>
#include "os345.h"
#include "os345fat.h"

// ***********************************************************************
// ***********************************************************************
// project 6 variables

// RAM disk
extern unsigned char RAMDisk[SECTORS_PER_DISK * BYTES_PER_SECTOR];
extern unsigned char FAT1[];			// current fat table
extern unsigned char FAT2[];			// secondary fat table
extern FDEntry OFTable[];	          	// open files
extern char dirPath[128];				// directory path

extern TCB tcb[];						// task control block
extern int curTask;						// current task #
extern bool diskMounted;				// disk has been mounted

FMSERROR FMSErrors[NUM_ERRORS]   = {
        {ERR50, ERR50_MSG},  // Invalid File Name
        {ERR51, ERR51_MSG},  // Invalid File Type
        {ERR52, ERR52_MSG},  // Invalid File Descriptor
        {ERR53, ERR53_MSG},  // Invalid Sector Number
        {ERR54, ERR54_MSG},  // Invalid FAT Chain
        {ERR55, ERR55_MSG},  // Invalid Directory

        {ERR60, ERR60_MSG},  // File Already Defined
        {ERR61, ERR61_MSG},  // File Not Defined
        {ERR62, ERR62_MSG},  // File Already Open
        {ERR63, ERR63_MSG},  // File Not Open
        {ERR64, ERR64_MSG},  // File Directory Full
        {ERR65, ERR65_MSG},  // File Space Full
        {ERR66, ERR66_MSG},  // End-Of-File
        {ERR67, ERR67_MSG},  // End-Of-Directory
        {ERR68, ERR68_MSG},  // Directory Not Found
        {ERR69, ERR69_MSG},  // Can Not Delete

        {ERR70, ERR70_MSG},  // Too Many Files Open
        {ERR71, ERR71_MSG},  // Not Enough Contiguous Space
        {ERR72, ERR72_MSG},  // Disk Not Mounted

        {ERR80, ERR80_MSG},  // File Seek Error
        {ERR81, ERR81_MSG},  // File Locked
        {ERR82, ERR82_MSG},  // File Delete Protected
        {ERR83, ERR83_MSG},  // File Write Protected
        {ERR84, ERR84_MSG},  // Read Only File
        {ERR85, ERR85_MSG}   // Illegal Access
};

int sectorReads;
int sectorWrites;

// ***********************************************************************
// project 6 functions and tasks


// ***********************************************************************
// ***********************************************************************


// ***********************************************************************
// ***********************************************************************
// p6 - runs finalTest
//
int P6_project6(int argc, char* argv[])
{
    char* newArgv[] = { {"finalTest"}, {"All"} };

    if (sizeof(DirEntry) != 32)
    {
        printf("\n***Incompatible long data type in DirEntry***");
        return 0;
    }

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }

    P6_chkdsk(0, (char**)0);			// check RAM disk
    P6_finalTest(2, newArgv);			// all final tests
    return 0;
} // end P6_project6



// ***********************************************************************
// ***********************************************************************
// cd <fileName>
int P6_cd(int argc, char* argv[])			// change directory
{
    int error;

    if (argc < 2)
    {
        printf("\n  CD <fileName>");
        return 0;
    }

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (!(error = fmsChangeDir(argv[1]))) return 0;
    if (error == ERR67) error = ERR68;
    fmsError(error);
    return 0;
} // end P6_cd



// ***********************************************************************
// ***********************************************************************
// dir <mask>
int P6_dir(int argc, char* argv[])		// list directory
{
    int index = 0;
    DirEntry dirEntry;
    char mask[20];
    int error = 0;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2) strcpy(mask, "*.*");
    else strcpy(mask, argv[1]);

    //dumpRAMDisk("Root Directory", 19*512, 19*512+256);
    printf("\nName:ext                time      date    cluster  size");
    while (1)
    {
        error = fmsGetNextDirEntry(&index, mask, &dirEntry, CDIR);
        if (error)
        {
            if (error != ERR67) fmsError(error);
            break;
        }
        printDirectoryEntry(&dirEntry);
        SWAP;
    }
    //dumpRAMDisk("Root Directory", 19*512, 20*512);
    return 0;
} // end P6_dir



// ***********************************************************************
// ***********************************************************************
// fat {<TAB#>{,<LOC#>{,<END>}}}
//
//		1	fat					output fat 1 table
//		2	fat <1 to 2>		output fat <#> table
//		2	fat <# gt 2>		output fat 1 table entry <#>
//		3	fat <#>,<s>			output fat table <#> starting with entry <s>
//		4	fat <#>,<s>,<e>	output fat table <#> from <s> to <e>
//
void outFatEntry(int index)
{
    int fatvalue;

    printf("\n  FAT1[%d] = ", index);
    fatvalue = getFatEntry(index, FAT1);
    // Special formatting cases...
    if (index < 2) printf("RSRV");			// A reserved cluster
    else if (fatvalue == FAT_EOC) printf("EOC"); // The EOC marker
    else if (fatvalue == FAT_BAD) printf("BAD"); // The BAD cluster marker
    else printf("%d", fatvalue);
    return;
}

int P6_dfat(int argc, char* argv[])		// list FAT table
{
    int index;
    int start = 0;
    int end = 64;

    //		1	fat					output fat 1 table
    //		2	fat <1 to 2>		output fat <#> table
    //		2	fat <# gt 2>		output fat 1 table entry <#>
    //		3	fat <#>,<s>			output fat table <#> starting with entry <s>
    //		4	fat <#>,<s>,<e>	output fat table <#> from <s> to <e>

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    switch (argc)
    {
        case 1:						//	1	fat					output fat 1 table
        {
            printFatEntries("FAT1", start, end);
            break;
        }

        case 2:						//	2	fat <1 to 2>		output fat <#> table
        {
            char buf[32];
            index = INTEGER(argv[1]);
            if ((index == 1) || (index ==2))
            {
                sprintf(buf, "Disk Image: FAT %d", index);
                dumpRAMDisk(buf, (1+index*8)*512, (1+index*8)*512+64);
            }
            else
            {
                outFatEntry(index);
            }
            break;
        }

        case 3:						//	3	fat <#>,<s>			output fat table <#> starting with entry <s>
        {
            char* FATtb = (INTEGER(argv[1]) == 2) ? FAT2 : FAT1;
            start = INTEGER(argv[2]);
            end = start + 1;

            for (index=start; index<end; index++) outFatEntry(index);
            break;
        }

        case 4:						//	4	fat <#>,<s>,<e>	output fat table <#> from <s> to <e>
        {
            char* FATtb = (INTEGER(argv[1]) == 2) ? FAT2 : FAT1;
            start = INTEGER(argv[2]);
            end = INTEGER(argv[3]);

            for (index=start; start<end; index++) outFatEntry(index);
            break;
        }

    }
    return 0;
} // end P6_dfat



// ***********************************************************************
// ***********************************************************************
// mount <disk name>
//
int P6_mount(int argc, char* argv[])		// mount RAM disk
{
    int error;
    BSStruct bootSector;
    char temp[128] = {""};

    assert("64-bit" && (sizeof(DirEntry) == 32));

    if (argc < 2) strcat(temp, "c:/lcc/projects/disk4");
    else strcat(temp, argv[1]);
    printf("\nMount Disk \"%s\"", temp);

    error = fmsMount(temp, &RAMDisk);
    if (error)
    {
        printf("\nDisk Mount Error %d", error);
        return 0;
    }
    //dumpRAMDisk("Boot Sector", 0, 512-450);
    //printf("\nBoot size = %d", sizeof(BSStruct));
    fmsReadSector(&bootSector, 0);
    strncpy(temp, (char*)&bootSector.BS_OEMName, 8);
    temp[8] = 0;
    printf("\n                System: %s", temp);
    printf("\n          Bytes/Sector: %d", bootSector.BPB_BytsPerSec);
    printf("\n       Sectors/Cluster: %d", bootSector.BPB_SecPerClus);
    printf("\n      Reserved sectors: %d", bootSector.BPB_RsvdSecCnt);
    printf("\n            FAT tables: %d", bootSector.BPB_NumFATs);
    printf("\n  Max root dir entries: %d", bootSector.BPB_RootEntCnt);
    printf("\n        FAT-12 sectors: %d", bootSector.BPB_TotSec16);
    printf("\n           FAT sectors: %d", bootSector.BPB_FATSz16);		// FAT sectors (should be 9)
    printf("\n         Sectors/track: %d", bootSector.BPB_SecPerTrk);		// Sectors per cylindrical track
    printf("\n          Heads/volume: %d", bootSector.BPB_NumHeads);		// Heads per volume (2 for 1.4Mb 3.5" floppy)
    printf("\n        FAT-32 sectors: %ld", bootSector.BPB_HiddSec);		// Hidden sectors (0 for non-partitioned media)
    return 0;
} // end P6_mount



// ***********************************************************************
// ***********************************************************************
// run <fileName>
int P6_run(int argc, char* argv[])		// run lc3 program from RAM disk
{
    char fileName[128];
    char* myArgv[] = {"1", ""};

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\nRUN <fileName>");
        return 0;
    }
    strcpy(fileName, argv[1]);
    if (!strstr(fileName, ".hex")) strcat(fileName, ".hex");
    myArgv[1] = (char*)&fileName;
    createTask( myArgv[0],				// task name
                lc3Task,					// task
                MED_PRIORITY,			// task priority
                2,							// task argc
                myArgv);					// task arguments
    return 0;
} // end P6_run



// ***********************************************************************
// ***********************************************************************
// space
int P6_space(int argc, char* argv[])
{
    DiskSize dskSize;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    fmsDiskStats(&dskSize);
    printf("\nFree: %d", dskSize.free);
    printf("\nUsed: %d", dskSize.used);
    printf("\n Bad: %d", dskSize.bad);
    printf("\nSize: %d", dskSize.size);
    return 0;
} // end P6_space


// ***********************************************************************
// ***********************************************************************
// type <fileName>
int P6_type(int argc, char* argv[])		// display file
{
    int error, nBytes, FDs;
    char buffer[4];

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\n  type <file>");
        return 0;
    }
    printf("\nType File \"%s\"\n", argv[1]);	// ?? debug
    // open source file
    if ((FDs = fmsOpenFile(argv[1], 0)) < 0)
    {
        fmsError(FDs);
        return 0;
    }
    printf("\n FDs = %d\n", FDs);					// ?? debug
    while ((nBytes = fmsReadFile(FDs, buffer, 1)) == 1)
    {
        putchar(buffer[0]);
        SWAP;
    }
    if (nBytes != ERR66) fmsError(nBytes);
    if (error = fmsCloseFile(FDs)) fmsError(error);
    return 0;
} // end P6_type



// ***********************************************************************
// ***********************************************************************
//	copy <file1>,<file2>
int P6_copy(int argc, char* argv[])		 	// copy file
{
    int error, nBytes, FDs, FDd;
    char buffer[BYTES_PER_SECTOR + 1];

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 3)
    {
        printf("\n  copy <file1> <file2>");
        return 0;
    }
    // open source file
    if ((FDs = fmsOpenFile(argv[1], 0)) < 0)
    {	fmsError(FDs);
        return 0;
    }
    // open destination file
    if ((FDd = fmsOpenFile(argv[2], 1)) < 0)
    {	fmsCloseFile(FDs);
        fmsError(FDd);
        return 0;
    }
//    printf("\n FDs = %d\n FDd = %d\n", FDs, FDd);

    nBytes = 1;
    while (nBytes > 0)
    {
        error = 0;
        nBytes = fmsReadFile(FDs, buffer, BYTES_PER_SECTOR);
        SWAP;
        if (nBytes < 0) break;
        error = fmsWriteFile(FDd, buffer, nBytes);
        if (error < 0) break;
        //for (error=0; error<nBytes; error++) putchar(buffer[error]);
    }
    if (nBytes != ERR66) fmsError(nBytes);
    if (error) fmsError(error);

    error = fmsCloseFile(FDs);
    if (error) fmsError(error);

    error = fmsCloseFile(FDd);
    if (error) fmsError(error);
    return 0;
} // end P6_copy



// ***********************************************************************
// ***********************************************************************
// df <fileName>
int P6_define(int argc, char* argv[])			// define file
{
    int error;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\n  DF <fileName>");
        return 0;
    }
    if ((error = fmsDefineFile(argv[1], ARCHIVE)) < 0)
    {
        fmsError(error);
    }
    return 0;
} // end P6_define



// ***********************************************************************
// ***********************************************************************
// del <fileName>
int P6_del(int argc, char* argv[])				// delete file
{
    int error;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\n  DL <fileName>");
        return 0;
    }
    if ((error = fmsDeleteFile(argv[1])) < 0)
    {
        fmsError(error);
    }
    return 0;
} // end P6_del



// ***********************************************************************
// ***********************************************************************
// mkdir <fileName>
int P6_mkdir(int argc, char* argv[])				// create directory file
{
    int error;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\n  MK <fileName>");
        return 0;
    }
    if ((error = fmsDefineFile(argv[1], DIRECTORY)) < 0)
    {
        fmsError(error);
    }
    return 0;
} // P6_mkdir



// ***********************************************************************
// ***********************************************************************
// unmount <diskname>
int P6_unmount(int argc, char* argv[])			// save ram disk
{
    int error;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\n  UM <fileName>");
        return 0;
    }
    if ((error = fmsUnMount(argv[1], RAMDisk)) < 0)
    {
        fmsError(error);
    }
    return 0;
} // end P6_unmount



// ***********************************************************************
// ***********************************************************************
// ds <sector>
int P6_dumpSector(int argc, char* argv[])	// dump RAM disk sector
{
    char temp[32];
    int sector;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    printf("\nValidate arguments...");	// ?? validate arguments
    sector = INTEGER(argv[1]);

    sprintf(temp, "Sector %d:", sector);
    dumpRAMDisk(temp, sector*512, sector*512 + 512);
    return 0;
} // end P6_dumpSector



// ***********************************************************************
// ***********************************************************************
// fs
int P6_fileSlots(int argc, char* argv[])	// list open file slots
{
    int i, fd;
    FDEntry* fdEntry;

    printf("\nSlot  Name    Ext  Atr  Size  Strt  Curr  cDir  cPID  Mode  Flag  Indx");
    for (fd = 0; fd < NFILES; fd++)
    {
        fdEntry = &OFTable[fd];
        if (fdEntry->name[0] == 0) continue;      // open slot
        printf("\n %2u   ", fd);
        for (i=0; i<12; i++) printf("%c", fdEntry->name[i]);
        printf("  %02x%6u%6u%6u%6u%6u%6u%6u%6u",
               fdEntry->attributes,
               fdEntry->fileSize,
               fdEntry->startCluster,
               fdEntry->currentCluster,
               fdEntry->directoryCluster,
               fdEntry->pid,
               fdEntry->mode,
               fdEntry->flags,
               fdEntry->fileIndex);
    }
    return 0;
} // end P6_fileSlots



// ***********************************************************************
// ***********************************************************************
// *	Support functions
// ***********************************************************************
// Print directory entry
void printDirectoryEntry(DirEntry* dirent)
{
    int i = 7;
    char p_string[64] = "              ------  00:00:00 03/01/2004";
    FATDate date;											// The Date bit field structure
    FATTime time;											// The Time bit field structure

    strncpy(p_string, (char*)&(dirent->name), 8);	// Copies 8 bytes from the name
    while (p_string[i] == ' ') i--;
    p_string[i+1] = '.';									// Add extension
    strncpy(&p_string[i+2], (char*)&(dirent->extension), 3);
    while (p_string[i+4] == ' ') i--;
    if (p_string[i+4] == '.') p_string[i+4] = ' ';

    // Generate the attributes
    if(dirent->attributes & 0x01) p_string[14] = 'R';
    if(dirent->attributes & 0x02) p_string[15] = 'H';
    if(dirent->attributes & 0x04) p_string[16] = 'S';
    if(dirent->attributes & 0x08) p_string[17] = 'V';
    if(dirent->attributes & 0x10) p_string[18] = 'D';
    if(dirent->attributes & 0x20) p_string[19] = 'A';

    // Extract the time and format it into the string...
    memcpy(&time, &(dirent->time), sizeof(FATTime));
    sprintf(&p_string[22], "%02u:%02u:%02u  ", time.hour, time.min, time.sec*2);

    // Extract the date and format it as well, inserting it into the string...
    memcpy(&date, &(dirent->date), sizeof(FATDate));
    sprintf(&p_string[31], "%02u/%02u/%04u %5u %5u",
            date.month+1, date.day, date.year+1980,
            dirent->startCluster, dirent->fileSize);

    // p_string is now ready!
    printf("\n%s", p_string);
    return;
} // end PrintDirectoryEntry


// ***********************************************************************
// print FAT table
void printFatEntries(unsigned char* FAT, int start, int end)
{
    char tbuf[16];
    char fbuf[100];
    unsigned short fatvalue;
    int i, nn, counter = 0;;

    nn = (512 * 9) / 1.5;						// The number of fat entries in the FAT table
    if (end < nn) nn = end;

    sprintf(fbuf, "\n    %6u:", start);
    for (i=start; i<nn; i++)
    {
        if (!(counter%10) && counter)
        {
            printf("%s", fbuf);
            sprintf(fbuf, "\n    %6u:", i);
        }
        fatvalue = getFatEntry(i, FAT);
        // Special formatting cases...
        if (i < 2) sprintf(tbuf, " RSRV"); 							// A reserved cluster
        else if (fatvalue == FAT_EOC) sprintf(tbuf, "  EOC"); // The EOC marker
        else if (fatvalue == FAT_BAD) sprintf(tbuf, "  BAD"); // The BAD cluster marker
        else sprintf(tbuf, "%5u", fatvalue);
        strcat(fbuf, tbuf);
        counter++;
    }
    if (counter%10) printf("%s", fbuf);
    return;
} // End PrintFatTable



// ***********************************************************************
// dm <sa> <ea> - dump dumpRAMDisk memory
void dumpRAMDisk(char *s, int sa, int ea)
{
    int i, ma;
    unsigned char j;

    printf("\n%s", s);
    for (ma = sa; ma < ea; ma+=16)
    {
        printf("\n0x%08x:", ma);
        for (i=0; i<16; i++)
        {
            printf(" %02x", (unsigned char)RAMDisk[ma+i]);
        }
        printf("  ");
        for (i=0; i<16; i++)
        {
            j = RAMDisk[ma+i];
            if ((j<20) || (j>127)) j='.';
            printf("%c", j);
        }
    }
    return;
} // end dumpRAMDisk


// ***********************************************************************
// ***********************************************************************
//	*																							 *
//	*	    PPPPPP     AA     SSSSS   SSSSS    OOOO   FFFFFF FFFFFF 		 *
//	*	    PP   PP   AAAA   SS   SS SS   SS  OO  OO  FF     FF  	  		 *
//	*	    PP   PP  AA  AA  SSSS    SSSS    OO    OO FF     FF    			 *
//	*	    PPPPPP  AAAAAAAA    SSS     SSS  OO    OO FFFF   FFFF  			 *
//	*	    PP      AA    AA SS   SS SS   SS  OO  OO  FF     FF    			 *
//	*	    PP      AA    AA  SSSSS   SSSSS    OOOO   FF     FF    			 *
//	*																							 *
// ***********************************************************************
// ***********************************************************************

// ***********************************************************************
// ***********************************************************************
// passoff functions and tasks
#define ckFAT1	FAT1
#define ckFAT2	FAT2

int isValidDirEntry(DirEntry* dirEntry);
void getFileName(char* fileName, DirEntry* dirEntry);
void checkDirectory(char* dirName, unsigned char fat[], int dir);

// ***********************************************************************
// ***********************************************************************
//	check disk for errors
//
int P6_chkdsk(int argc, char* argv[])		// check RAM disk
{
    int i, j;
    unsigned char fat[CLUSTERS_PER_DISK];

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    printf("\nChecking disk...");
    // set fat if cluster allocated
    for (i=2; i<CLUSTERS_PER_DISK; i++)
    {
        fat[i] = getFatEntry(i,ckFAT1) ? 1 : 0;
    }
    // process all directory entries
    checkDirectory("Root", fat, 0);
    // check to see if there are any zombie clusters
    j = 0;
    for (i=2; i<CLUSTERS_PER_DISK; i++)
    {
        if (fat[i])
        {
            SWAP;
            if (j)
            {
                if (++j == i) continue;
                printf("-%d", --j);
            }
            else
            {
                printf("\n  Orphaned Clusters: ");
            }
            printf(",  %d", i);
            j = i;
        }
    }
    if (j) printf("-%d", j);
    // reconcile fat tables
    for (i=0; i<CLUSTERS_PER_DISK; i++)
    {
        if (getFatEntry(i,ckFAT1) != getFatEntry(i,ckFAT2))
        {
            printf("\n  FAT1[%d] != FAT2[%d] (%d/%d)",
                   i, i, getFatEntry(i,ckFAT1), getFatEntry(i,ckFAT2));
        }
    }
    return 0;
} // end P6_chkdsk


// ***********************************************************************
// chkdsk utilities
// ***********************************************************************
//
//		getFileName
//
//		IN:	*fileName	pointer to buffer of at least 16 bytes
//				*dirEntry	32-byte directory entry
//
void getFileName(char* fileName, DirEntry* dirEntry)
{
    int i = 7;

    memset(fileName, 0, 16);
    strncpy(fileName, (char*)&(dirEntry->name), 8);	// Copies 8 bytes from the name
    i = strlen(fileName) - 1;
    while (fileName[i] == ' ') i--;
    fileName[++i] = '.';									// Add extension
    strncpy(&fileName[++i], (char*)&(dirEntry->extension), 3);
    i = strlen(fileName) - 1;
    while (fileName[i] == ' ') i--;
    if (fileName[i] == '.') fileName[i] = 0;
    return;
} // end getFileName



// ***********************************************************************
//	check for valid directory entry
int isValidDirEntry(DirEntry* dirEntry)
{
    char name[16];
    char fileName[16];
    int error = 0;

    getFileName(fileName, dirEntry);
    strncpy(name, (char*)dirEntry->name, 11);
    name[11] = 0;
    if (strlen(name) != 11)
    {
        printf("\n  Illegal NULL in file name \"%s\"", fileName);
        error = 1;
    }
    // check for invalid characters
    if (strpbrk(name, ".\"\\/:*<>|?"))
    {
        printf("\n  Illegal character in file name \"%s\"", fileName);
        error = 1;
    }
    return error;
} // end isValidDirEntry


// ***********************************************************************
//	check directory (recursively)
void checkDirectory(char* dirName, unsigned char fat[], int dir)
{
    int error, index = 0;
    DirEntry dirEntry;
    char fileName[32];
    unsigned long maxSize;

    //	check for dot/dotdot
    if (dir)
    {
        index = 0;
        if (fmsGetNextDirEntry(&index, ".", &dirEntry, dir) < 0)
            printf("\n  \".\" missing from \"%s\" directory", dirName);
        index = 0;
        if (fmsGetNextDirEntry(&index, "..", &dirEntry, dir) < 0)
            printf("\n  \"..\" missing from \"%s\" directory", dirName);
    }
    index = 0;
    while (1)
    {
        if (fmsGetNextDirEntry(&index, "*.*", &dirEntry, dir)) break;
        // process file name
        getFileName(fileName, &dirEntry);
        if (dirEntry.attributes & (VOLUME || DIRECTORY))
            printf("\n  Attribute 0x%02x is illegal in file \"%s\"", dirEntry.attributes, fileName);
        if (dirEntry.name[0] == '.') continue;
        else
        {	// follow clusters and clear fat
            unsigned char chain[CLUSTERS_PER_DISK];
            unsigned int i = dirEntry.startCluster;
            // check for valid file name
            isValidDirEntry(&dirEntry);
            memset(chain, 0, CLUSTERS_PER_DISK);
            error = 0;
            maxSize = 0;
            while (i)
            {
                maxSize += BYTES_PER_SECTOR;
                // check for illegal cluster
                if ((i < 2) || (i > CLUSTERS_PER_DISK))
                {
                    printf("\n  Illegal reference to cluster %d in file \"%s\"", i, fileName);
                    error = 1;
                    break;
                }
                // check for loop
                if (chain[i]++)
                {
                    printf("\n  Loop detected at cluster %d in file \"%s\"", i, fileName);
                    error = 2;
                    break;
                }
                // check for cross chains
                if (!fat[i])
                {
                    printf("\n  Cross chain detected at cluster %d in file \"%s\"", i, fileName);
                    error = 3;
                    break;
                }
                // mark cluster as used, get next cluster
                fat[i] = 0;
                i = getFatEntry(i,ckFAT1);
                if (i == FAT_EOC) break;	   // EOD
                if (i == FAT_BAD) break;
            }
        }
        // if no loop and directory, then recurse
        if ((error != 2) && (dirEntry.attributes & DIRECTORY))
        {
            // file size of directory should be 0
            if (dirEntry.fileSize)
                printf("\n  Non-zero file size of %u in directory \"%s\"", dirEntry.fileSize, fileName);
            checkDirectory(fileName, fat, dirEntry.startCluster);
        }
        else
        {	// check file size
            if (dirEntry.fileSize > maxSize)
                printf("\n  File size of %u in file \"%s\" exceeds %u", dirEntry.fileSize, fileName, maxSize);
        }
    }
    return;
} // end checkDirectory


// ***********************************************************************
// final pass-off routine
#define FERROR(s1,s2,e) { printf(s1,s2); fmsError(e); return e; }
#define numWords	16
#define numFiles	64
#define numDirs	128
#define numTests	6

#define try(s1) if((error=s1)<0){printf("\nFailed \"%s\"",#s1);fmsError(error);return error;}

int fmsTests(int test, int debug);
extern int P6_fileSlots(int, char**);	// list open file slots
extern int P6_dir(int, char**);			// list current directory

int P6_finalTest(int argc, char* argv[])
{
    int i, flags = 0;
    int finalDebug = 0;

    if (!diskMounted)
    {
        fmsError(ERR72);
        return 0;
    }
    if (argc < 2)
    {
        printf("\n  final 1   Define 128 directories, 64 files");
        printf("\n  final 2   Open 32 files, write, rewind, print, close");
        printf("\n  final 3   Open and append words");
        printf("\n  final 4   Random access on sector boundaries");
        printf("\n  final 5   Creating and deleting directories");
        printf("\n  final 6   Delete all test 1 files/directories");
        printf("\n  final all Run all tests");
        return 0;
    }
    if (toupper(argv[1][0]) == 'A') flags = 0x3f;
    else
    {
        flags = 0;
        for (i=1; i<argc; i++)
        {
            flags |= 1 << (INTEGER(argv[i]) - 1);
            printf("\n  Run test #%d", INTEGER(argv[i]));
        }
        printf("\n  flags = %02x", flags);
    }

    sectorReads = 0;
    sectorWrites = 0;
    for (i=1; i<=numTests; i++)
    {
        if (flags & (1 << (i-1)))
        {
            if (fmsTests(i, finalDebug))
            {
                printf("\nFAILED TEST %d!", i);
                return 0;
            }
        }
    }
    // list system
    P6_fileSlots(0, 0);		// list open file slots
    P6_dir(0, 0);				// list directory

    printf("\nSector reads = %d", sectorReads);
    printf("\nSector writes = %d", sectorWrites);
    printf("\nCONGRATULATIONS!  YOU PASS!");
    return 0;
} // end P6_finalTest


// ***********************************************************************
int fmsTests(int test, bool debug)
{
    char buf[32], buf1[32], buf2[32];
    char rBuf[128];
    char result[] = "Now is the time for all good men to come to the aid of their country.";
    int i, error;
    int tFID[numFiles];
    char* text[numWords] = {"Now ", "is ", "the ", "time ", "for ",
                            "all ", "good ", "men ", "to ", "come ",
                            "to ", "the ", "aid ", "of ", "their ",
                            "country." };
    switch (test)
    {
        case 1:					// file creation
        {
            printf("\nRunning Test 1...");
            // create numDirs directories in current directory
            printf("\n  Define %d directories...", numDirs);
            for (i=0; i<numDirs; i++)
            {	sprintf(buf, "dfile%d", i);
                if (debug) printf("\n   fmsDefineFile(\"%s\")", buf);
                try(fmsDefineFile(buf, DIRECTORY));
            }

            // create numFiles files in current directory
            printf("\n  Define %d files...", numFiles);
            for (i=0; i<numFiles; i++)
            {	sprintf(buf, "file%d.txt", i);
                if (debug) printf("\n   fmsDefineFile(\"%s\")", buf);
                try(fmsDefineFile(buf, ARCHIVE));
            }
            break;
        }

        case 2:					// open files
        {
            printf("\nRunning Test 2...");
            // try to open numFiles files for read/write access
            // note: the number of open files is limited to the number of file slots
            printf("\n  Open %d files...", numFiles);
            for (i=0; i<numFiles; i++)
            {
                sprintf(buf, "file%d.txt", i);
                if ((tFID[i] = fmsOpenFile(buf, OPEN_RDWR)) < 0)
                {	if (i == NFILES) break;
                    FERROR("\nFailed fmsOpenFile(\"%s\") with R/W",buf,tFID[i]);
                }
            }
            // write a word to each file, rewind the files (seek to 0), read and print word
            for (i=0; i<numWords; i++)
            {
                if (debug) printf("\n   fmsWriteFile(tFID[%d], \"%s\", %d)", i, text[i], strlen(text[i]));
                try(fmsWriteFile(tFID[i],text[i],strlen(text[i])));
            }
            // seek to beginning of files
            for (i=0; i<numWords; i++)
            {
                try(fmsSeekFile(tFID[i],0));
                if (debug) printf("\n   fmsSeekFile(tFID[%d], 0) = %d", i, error);
            }
            // read from numWords files
            rBuf[0] = 0;
            for (i=0; i<numWords; i++)
            {
                try(fmsReadFile(tFID[i], buf, strlen(text[i])));
                strncat(rBuf, buf, strlen(text[i]));
            }
            printf("\n  %s", rBuf);

            // close files
            for (i=0; i<NFILES; i++)
            {
                if (debug) printf("\n  fmsCloseFile(%d)", tFID[i]);
                try(fmsCloseFile(tFID[i]));
            }
            return strcmp(rBuf, result);
        }

        case 3:
        {
            // close/open word file and append to test2 file
            // then print test2 file
            int test2 = numFiles < NFILES ? numFiles-1 : NFILES-1;
            printf("\nRunning Test 3...");
            sprintf(buf2, "file%d.txt", test2);
            for (i=0; i<numWords; i++)
            {
                sprintf(buf, "file%d.txt", i);
                // open word file
                if (debug) printf("\n  fmsOpenFile(%s, OPEN_READ)", buf);
                try(tFID[i] = fmsOpenFile(buf, OPEN_READ));
                // open test2 file for appending
                if (debug) printf("\n  fmsOpenFile(%s, OPEN_APPEND)", buf2);
                try(tFID[test2] = fmsOpenFile(buf2, OPEN_APPEND));
                // read word from word file
                try(fmsReadFile(tFID[i], buf, strlen(text[i])));
                // write to buffer
                try(fmsWriteFile(tFID[test2], buf, strlen(text[i])));
                // close word file
                if (debug) printf("\n  fmsCloseFile(%d)", tFID[i]);
                try(fmsCloseFile(tFID[i]));
                // close test2 file
                if (debug) printf("\n  fmsCloseFile(%d)", test2);
                try(fmsCloseFile(tFID[test2]));
            }
            // read and print test2 file
            try(tFID[test2] = fmsOpenFile(buf2, OPEN_READ));
            rBuf[0] = 0;
            while ((error = fmsReadFile(tFID[test2], buf, 1)) > 0) strncat(rBuf, buf, 1);
            if ((error < 0) & (error != ERR66))
            FERROR("\nFailed fmsReadFile(%d)",tFID[test2],error);
            printf("\n  %s", rBuf);

            if (debug) printf("\n  fmsCloseFile(%d)", test2);
            try(fmsCloseFile(tFID[test2]));
            return strcmp(rBuf, result);
        }

        case 4:
        {
            int test3 = numFiles < NFILES ? numFiles-2 : NFILES-2;
            int t3FID;
            int fileSize = 10*512;
            int index[numWords] =  {510, 20, 5120, 1024, 0, 4095, 4000, 5000,
                                    100, 5090, 3000, 2000, 1535, 3100, 1900, 4500 };
            // write X's to test3 file
            // seek and write test words throughout test3 file
            // seek/read/print test words from test3 file
            printf("\nRunning Test 4...");
            sprintf(buf2, "file%d.txt", test3);

            if (debug) printf("\n  fmsOpenFile(\"%s\", %d)", buf2, OPEN_RDWR);
            try(t3FID = fmsOpenFile(buf2, OPEN_RDWR));

            // write file with X's
            if (debug) printf("\n  Write %d X's to \"%s\"", fileSize, buf2);
            for (i=0; i<fileSize; i++)
            {
                try(fmsWriteFile(t3FID, "X", 1));
            }

            // seek to write text
            for (i=0; i<numWords; i++)
            {
                if (debug) printf("\n  Write \"%s\" to position %d", text[i], index[i]);
                try(fmsSeekFile(t3FID, index[i]));
                try(fmsWriteFile(t3FID, text[i], strlen(text[i])));
            }

            // seek to read file
            rBuf[0] = 0;
            for (i=0; i<numWords; i++)
            {	//memset(buf, 0, sizeof(buf));
                try(fmsSeekFile(t3FID, index[i]));
                if ((error = fmsReadFile(t3FID, buf, strlen(text[i]))) > 0)
                    strncat(rBuf, buf, strlen(text[i]));
                if (error <= 0) FERROR("\nFailed fmsReadFile(%d)",t3FID,error);
            }
            printf("\n  %s", rBuf);

            if (debug) printf("\n  fmsCloseFile(%d)", t3FID);
            try(fmsCloseFile(t3FID));
            return strcmp(rBuf, result);
        }

        case 5:
        {
            printf("\nRunning Test 5...");
            // define test directory
            strcpy(buf, "TESTDIR");
            printf("\n  fmsMakeDirectory(\"%s\")", buf);
            try(fmsDefineFile(buf, DIRECTORY));
            // change directories
            printf("\n  fmsChangeDir(\"%s\")", buf);
            try(fmsChangeDir(buf));
            // create numFiles files in current directory
            printf("\n  Define %d files...", numFiles);
            for (i=0; i<numFiles; i++)
            {	sprintf(buf1, "file%d.txt", i);
                if (debug) printf("\n  fmsDefineFile(\"%s\")", buf1);
                try(fmsDefineFile(buf1, ARCHIVE));
            }
            // go up one directory
            strcpy(buf2, "..");
            printf("\n  fmsChangeDir(\"%s\")", buf2);
            try(fmsChangeDir(buf2));
            // try to delete directory
            printf("\n  fmsDeleteFile(\"%s\")", buf);
            if ((error = fmsDeleteFile(buf)) != ERR69)
            FERROR("\nFailed fmsDeleteFile(\"%s\")",buf,error);
            printf(" Can Not Delete... Good!");
            // go back into directory
            printf("\n  fmsChangeDir(\"%s\")", buf);
            try(fmsChangeDir(buf));
            // delete all the files
            printf("\n  Delete %d files...", numFiles);
            for (i=0; i<numFiles; i++)
            {	sprintf(buf1, "file%d.txt", i);
                if (debug) printf("\n  fmsDeleteFile(\"%s\")", buf1);
                try(fmsDeleteFile(buf1));
                if (i == 14) P6_dir(0, 0);
            }
            // go up one directory again
            strcpy(buf2, "..");
            printf("\n  fmsChangeDir(\"%s\")", buf2);
            try(fmsChangeDir(buf2));
            // try to delete directory again
            printf("\n  fmsDeleteFile(\"%s\")", buf);
            try(fmsDeleteFile(buf));
            break;
        }

        case 6:
        {
            // delete numFiles files
            printf("\nRunning Test 6...");
            printf("\n  Delete %d files...", numFiles);
            for (i=0; i<numFiles; i++)
            {	sprintf(buf, "file%d.txt", i);
                if (debug) printf("\n  fmsDeleteFile(\"%s\")", buf);
                try(fmsDeleteFile(buf));
            }

            // delete numDirs directories
            printf("\n  Delete %d directories...", numDirs);
            for (i=0; i<numDirs; i++)
            {	sprintf(buf, "dfile%d", i);
                if (debug) printf("\n  fmsDeleteFile(\"%s\")", buf);
                try(fmsDeleteFile(buf));
            }
            break;
        }

        default:
            printf("\nInvalid test!");
    }
    return 0;
} // end finalTest



// ***********************************************************************
// ***********************************************************************
//	Unit test routines for open, read, write, seek, and close FMS functions
//
//	1. Add the following prototypes to os345.h:
//
//		int P6_open(int, char**);
//		int P6_read(int, char**);
//		int P6_write(int, char**);
//		int P6_seek(int, char**);
//		int P6_close(int, char**);
//
//	2. Add the following shell commands to os345p1.c:
//
//		{	"open",			"op",		P6_open,					"Open file test"	},
//		{	"read",			"rd",		P6_read,					"Read file test"	},
//		{	"write",			"wr",		P6_write,				"Write file test"	},
//		{	"seek",			"sk",		P6_seek,					"Seek file test"	},
//		{	"close",			"cl",		P6_close,				"Close file test"	},
//
//	3. Mount disk4:
//
//		CS345 F2008
//		0>>mount
//		Mount Disk "c:/lcc/projects/disk4"
//		                System: IBM  3.3
//		          Bytes/Sector: 512
//		       Sectors/Cluster: 1
//		      Reserved sectors: 1
//		            FAT tables: 2
//		  Max root dir entries: 224
//		        FAT-12 sectors: 2880
//		           FAT sectors: 9
//		         Sectors/track: 18
//		          Heads/volume: 2
//		        FAT-32 sectors: 0
//		c:/lcc/projects/disk4:\>>
//
//	4. List root director (validates fmsGetNextDirEntry for root):
//
//		c:/lcc/projects/disk4:\>>dir
//		Name:ext                time      date    cluster  size
//		BIGDIR        ----D-  11:31:40 03/31/2004     3     0
//		BYU           ----D-  11:34:54 03/31/2004   171     0
//		JOKES         ----D-  11:37:06 03/31/2004   800     0
//		LONGFI~1      ----D-  11:37:14 03/31/2004   875     0
//		PERSONAL      ----D-  11:37:18 03/31/2004   937     0
//		TEMP          ----D-  11:37:36 03/31/2004  1355     0
//		H2O.C         -----A  19:00:02 02/12/2004  1380  3425
//		MAKE.TXT      -----A  16:26:58 02/27/2004  1387 18584
//		c:/lcc/projects/disk4:\>>
//
//	5. Open MAKE.TXT and H2O.C:
//
//		c:/lcc/projects/disk4:\>>open make.txt
//		Open File "make.txt",read
//		Slot  Name    Ext  Atr  Size  Strt  Curr  cDir  cPID  Mode  Flag  Indx
//		  0   MAKE    TXT   20 18584  1387     0     0     0     0     0     0
//		FileID = 0
//		c:/lcc/projects/disk4:\>>open h2o.c
//		Open File "h2o.c",read
//		Slot  Name    Ext  Atr  Size  Strt  Curr  cDir  cPID  Mode  Flag  Indx
//		  0   MAKE    TXT   20 18584  1387     0     0     0     0     0     0
//		  1   H2O     C     20  3425  1380     0     0     0     0     0     0
//		FileID = 1
//
//	6. Read from last opened file (H2O.c):
//
//		c:/lcc/projects/disk4:\>>read 20
//		Buffer[0-20] = // Hex to Object 01/
//		Slot  Name    Ext  Atr  Size  Strt  Curr  cDir  cPID  Mode  Flag  Indx
//		  0   MAKE    TXT   20 18584  1387     0     0     0     0     0     0
//		  1   H2O     C     20  3425  1380  1380     0     0     0     0    20
//		c:/lcc/projects/disk4:\>>read 500
//		Buffer[0-500] = 24/2004
//		#include <stdio.h>
//		...500 bytes...
//
//		Slot  Name    Ext  Atr  Size  Strt  Curr  cDir  cPID  Mode  Flag  Indx
//		  0   MAKE    TXT   20 18584  1387     0     0     0     0     0     0
//		  1   H2O     C     20  3425  1380  1381     0     0     0     0   520
//		c:/lcc/projects/disk4:\>>
//
//	7. Use the commands to test you file manager:
//
//		>>open <fileName>{,<mode>}
// 	>>read {<# of bytes>}
// 	>>write {<# of bytes>}
// 	>>seek {<seekIndex>}
// 	>>close {<fileId>}
//
//
// ***********************************************************************
// ***********************************************************************
//	Open file
//
//		>>open <fileName>{,<mode>}
//
//		where <fileName> = current directory file name
//				<mode> = 0=OPEN_READ
//							1=OPEN_WRITE
//							2=OPEN_APPEND
//							3=OPEN_RDWR
//
int lastFD;										// fileid of last opened file

int P6_open(int argc, char* argv[])		// open file
{
    int error, mode;
    char* omode[] = {"read", "write", "append", "r/w"};

    if (argc < 3) mode = OPEN_READ;
    else mode = INTEGER(argv[2]);
    mode %= 4;

    printf("\nOpen File \"%s\",%s", argv[1], omode[mode]);

    // open source file
    if ((lastFD = fmsOpenFile(argv[1], mode)) < 0)
    {
        fmsError(lastFD);
        return 0;
    }
    printf("\nFileID = %d", lastFD);

    SWAP;
//	P6_fileSlots(0, (char**)0);
    return 0;
} // end P6_type



// ***********************************************************************
// ***********************************************************************
//	Read and print bytes from file
//
// 	>>read {<# of bytes>}
//
//		where <# of bytes> = # of bytes to read from file
//									(default = 1, max = 512)
//
int P6_read(int argc, char* argv[])		// read file
{
    int error, nBytes;
    char buffer[520];

    if (argc < 2) nBytes = 1;
    else nBytes = INTEGER(argv[1]);
    nBytes %= 512;

    if ((error = fmsReadFile(lastFD, buffer, nBytes)) < 0)
    {
        fmsError(error);
        return 0;
    }
    // terminate buffer
    buffer[error] = 0;
    printf("\nBuffer[0-%d] = %s", error, buffer);

    SWAP;
    P6_fileSlots(0, (char**)0);
    return 0;
} // end P6_read



// ***********************************************************************
// ***********************************************************************
//	Write and print alphabet to file
//
// 	>>write {<# of bytes>}
//
//		where <# of bytes> = # of bytes to write to file
//									(default = 1, max = 52)
//
int P6_write(int argc, char* argv[])		// write file
{
    int error, nBytes;
    char buffer[520];
    strcpy(buffer, "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz");

    if (argc < 2) nBytes = 1;
    else nBytes = INTEGER(argv[1]);
    nBytes %= strlen(buffer);

    if ((error = fmsWriteFile(lastFD, buffer, nBytes)) < 0)
    {
        fmsError(error);
        return 0;
    }

    buffer[nBytes] = 0;
    printf("\nWrite = %s", buffer);

    SWAP;
    P6_fileSlots(0, (char**)0);
    return 0;
} // end P6_write


// ***********************************************************************
// ***********************************************************************
//	Seek within last opened file file
//
// 	>>seek {<seekIndex>}
//
//		where <seekIndex> = byte index into last opened file
//								  (default = 0)
//
int P6_seek(int argc, char* argv[])		// seek file
{
    int error, fileID, seekIndex;

    // default to last accessed file or argument
    if (argc < 2) seekIndex = 0;
    else seekIndex = INTEGER(argv[1]);

    if ((error = fmsSeekFile(lastFD, seekIndex)) < 0)
    {
        fmsError(error);
        return 0;
    }

    SWAP;
    P6_fileSlots(0, (char**)0);
    return 0;
} // end P6_seek




// ***********************************************************************
// ***********************************************************************
//	Close file
//
// 	>>close {<fileId>}
//
//		where <fileId> = file ID as returned from open
//							  (default = last opened file)
//
int P6_close(int argc, char* argv[])		// close file
{
    int error, fileID;

    // default to last accessed file or argument
    if (argc < 2) fileID = lastFD;
    else fileID = INTEGER(argv[1]);

    if ((error = fmsCloseFile(fileID)) < 0)
    {
        fmsError(error);
        return 0;
    }

    SWAP;
    P6_fileSlots(0, (char**)0);
    return 0;
} // end P6_close





// ***************************************************************************************
// ***************************************************************************************
// Support functions
// ***************************************************************************************
// ***************************************************************************************

// ***************************************************************************************
// ***************************************************************************************
//	setDirTimeDate
//
//		struct tm
//		{
//			int tm_sec;     // 0 to 60
//			int tm_min;     // 0 to 59
//			int tm_hour;    // 0 to 23
//			int tm_mday;    // 1 to 31
//			int tm_mon;     // 0 to 11
//			int tm_year;    // year - 1900
//			int tm_wday;    // Sunday = 0
//			int tm_yday;    // 0 to 365
//			int tm_isdst;   // >0 if Daylight Savings Time,
//			                //  0 if Standard,
//			                // <0 if unknown
//			char *tm_zone;  // time zone name
//			long tm_gmtoff; // offset from GMT
//		};
//
void setDirTimeDate(DirEntry* dir)
{
    time_t a;
    struct tm *b;

    time(&a);
    b = localtime(&a);
    dir->date.year = b->tm_year + 1900 - 1980;
    dir->date.month = b->tm_mon;
    dir->date.day = b->tm_mday;

    dir->time.hour = b->tm_hour;
    dir->time.min = b->tm_min;
    dir->time.sec = b->tm_sec;
    return;
} // end setDirTimeDate



// ***************************************************************************************
// ***************************************************************************************
// Error processor
void fmsError(int error)
{
    int i;

    for (i=0; i<NUM_ERRORS; i++)
    {
        if (FMSErrors[i].error == error)
        {
            printf("\n%s", FMSErrors[i].error_msg);
            return;
        }
    }
    printf("\n%s %d", UNDEFINED_MSG, error);
    return;
} // end fmsError


// ***************************************************************************************
// ***************************************************************************************
//	check for valid DOS 8.3 file name
//
//	return 	 1 = valid 8.3 name
//				 0 = invalid name
//				-1 = valid long file name
//
//	Valid characters: ` ~ ! @ # $ % ^ & ( ) _ - { } '
// Cannot start with .
//	Invalid Characters: "  / : * < > | ?
//
//		while((string_ptr=strpbrk(string," "))!=NULL) *string_ptr='-';
//
int isValidFileName(char* fileName)
{
    char* s;
    // cannot start with '.'
    if (fileName[0] == '.') return 0;
    // check for invalid characters
    if (strpbrk(fileName, "\"/:*<>|?")) return 0;
    // check for double period
    if (s = strchr(fileName, '.'))
    {
        if (strchr(s+1, '.')) return 0;			// more than 1 '.'
        if (strlen(s+1) > 3) return 0;			// too long of extension
        if ((strlen(fileName) - strlen(s)) <= 8) return 1;
        else return -1;
    }
    if (strlen(fileName) <= 8) return 1;
    return -1;
} // end isValidFileName



// ***************************************************************************************
// ***************************************************************************************
int fmsMask(char* mask, char* name, char* ext)
{
    int i,j;
    // check for ..
    if (!strcmp(mask, ".."))
    if (!strncmp(name, "..", 2)) return 1;
    else return 0;

    // look thru name
    for (i=0,j=0; j<8; i++,j++)
    {
        if (mask[i] == '*') {i++; break;}
        if ((mask[i] == '.') && (name[j] == ' ')) {i++; break;}
        if ((mask[i] == '?') && (name[j] != ' ')) continue;
        if (!mask[i] && (name[j] == ' ') && (ext[0] == ' ')) return 1;
        if ((mask[i] != toupper(name[j])) && (mask[i] != tolower(name[j]))) return 0;
    }
    while (mask[i] == '.') i++;
    // check extension
    for (j=0; j<3; i++,j++)
    {
        if (mask[i] == '*') return 1;
        if (!mask[i] && (ext[j] == ' ')) return 1;
        if ((mask[i] == '?') && (ext[j] != ' ')) continue;
        if ((mask[i] != toupper(ext[j])) && (mask[i] != tolower(ext[j]))) return 0;
    }
    return 1;
} // end fmsMask



// ***************************************************************************************
// ***************************************************************************************
int fmsGetDirEntry(char* fileName, DirEntry* dirEntry)
// This function returns the directory entry from the current directory as
//    specified by fileName.
// Return 0 for success; otherwise, return an error number.
//
//    ERR61 = File Not Defined
{
    int error, index = 0;
    //if (isValidFileName(fileName) < 1) return ERR50;
    error = fmsGetNextDirEntry(&index, fileName, dirEntry, CDIR);
    return (error ? ((error == ERR67) ? ERR61 : error) : 0);
} // end fmsGetDirEntry



// ***************************************************************************************
// ***************************************************************************************
int fmsGetNextDirEntry(int *dirNum, char* mask, DirEntry* dirEntry, int dir)
//	Called by dir or ls command.
// This function returns the next directory entry of the current directory.
//	The dirNum parameter is set to 0 for the first entry and is subsequently
//    updated for each additional call.
//	The next directory entry is returned in the 32 byte directory structure dirEntry:
//	The parameter mask is a selection string.  If null, return next directory entry.
//    Otherwise, use the mask string to select the next directory entry.
//    A '*' is a wild card for any length string.
//    A '?' is a wild card for any single character.
//    Any other character must match exactly.
// NOTE:
//		*.*		all files
//		*			all files w/o extension
//		a*.txt	all files beginning with the character 'a' and with a .txt extension
//	Return 0 for success, otherwise, return the error number.
//
//    ERR54 = Invalid FAT Chain
//    ERR67 = End of Directory
{
    char buffer[BYTES_PER_SECTOR];
    int dirIndex, dirSector, error;
    int loop = *dirNum / ENTRIES_PER_SECTOR;
    int dirCluster = dir;

    while(1)
    {	// load directory sector
        if (dir)
        {	// sub directory
            while(loop--)
            {
                dirCluster = getFatEntry(dirCluster, FAT1);
                if (dirCluster == FAT_EOC) return ERR67;
                if (dirCluster == FAT_BAD) return ERR54;
                if (dirCluster < 2) return ERR54;
            }
            dirSector = C_2_S(dirCluster);
        }
        else
        {	// root directory
            dirSector = (*dirNum / ENTRIES_PER_SECTOR) + BEG_ROOT_SECTOR;
            if (dirSector >= BEG_DATA_SECTOR) return ERR67;
        }

        // read sector into directory buffer
        if (error = fmsReadSector(buffer, dirSector)) return error;

        // find next matching directory entry
        while(1)
        {	// read directory entry
            dirIndex = *dirNum % ENTRIES_PER_SECTOR;
            memcpy(dirEntry, &buffer[dirIndex * sizeof(DirEntry)], sizeof(DirEntry));
            if (dirEntry->name[0] == 0) return ERR67;	// EOD
            (*dirNum)++;                        		// prepare for next read
            if (dirEntry->name[0] == 0xe5);     		// Deleted entry, go on...
            else if (dirEntry->attributes == LONGNAME);
            else if (fmsMask(mask, dirEntry->name, dirEntry->extension)) return 0; // return if valid
            // break if sector boundary
            if ((*dirNum % ENTRIES_PER_SECTOR) == 0) break;
        }
        // next directory sector/cluster
        loop = 1;
    }
    return 0;
} // end fmsGetNextDirEntry

// ***************************************************************************************
// ***************************************************************************************
int fmsChangeDir(char* dirName)
//	Called by cd command.
// This function changes the current directory to the subdirectory specified by
//    the argument dirname.
// You will only need to handle moving up a directory or moving down a subdirectory.
//	Verify that dirname is a valid directory name in the current directory.
//	Return 0 for success, otherwise, return the error number.
{
    int i, error;
    DirEntry dirEntry;

    // need to allow for . and ..
    //if (isValidFileName(dirName) < 1) return ERR50;
    if ((error = fmsGetDirEntry(dirName, &dirEntry))) return error;
    if (dirEntry.attributes != DIRECTORY) return ERR55;
    CDIR = dirEntry.startCluster;

    // keep track of path name
    if (!strcmp(dirName, ".")) return 0;
    if (!strcmp(dirName, ".."))
    {	// drop last directory
        for (i=strlen(dirPath)-1; i>0; i--) if (dirPath[i] == '\\') break;
        if (dirPath[i-1] == ':') i++;
        dirPath[i] = '\0';
        return 0;
    }
    // add new path
    if (dirPath[strlen(dirPath)-1] != '\\') strcat(dirPath, "\\");
    strcat(dirPath, dirName);
    return 0;
} // end fmsChangeDir



// ***************************************************************************************
// ***************************************************************************************
// size disk
void sizeDisk(DiskSize* dskSize, char* mask, int dir)
{
    int index = 0;
    DirEntry dirEntry;

    while (1)
    {
        if (fmsGetNextDirEntry(&index, mask, &dirEntry, dir)) break;
        if (dirEntry.name[0] == '.') continue;
        dskSize->used += ((dirEntry.fileSize + BYTES_PER_SECTOR) / BYTES_PER_SECTOR);	         // # of sectors used
        if ((dirEntry.attributes == DIRECTORY) && (dirEntry.name[0] != '.'))
        {
            sizeDisk(dskSize, mask, dirEntry.startCluster);		// get space of subdirectory
            dskSize->used += ((dirEntry.fileSize + BYTES_PER_SECTOR) / BYTES_PER_SECTOR);	         // # of sectors used
        }
    }
    return;
} // end sizeDisk


int fmsDiskStats(DiskSize* dskSize)
//	Called by sp command.
// This function returns the number of free, used, bad, and total sectors
//    on your RAM disk in the structure dskSize.
//	Return 0 for success; otherwise, return an error number.
{
    sizeDisk(dskSize, "*.*", 0);
    dskSize->free = CLUSTERS_PER_DISK - dskSize->used;	// # of sectors free
    dskSize->bad = 0;  	                        // # of bad sectors
    dskSize->size = CLUSTERS_PER_DISK;	         // Total # of sectors in RAM disk
    return 0;
} // end fmsDiskStats



// ***************************************************************************************
// ***************************************************************************************
int fmsMount(char* fileName, void* ramDisk)
//	Called by mount command.
// This function loads a RAM disk image from a file.
//	The parameter fileName is the file path name of the disk image.
//	The parameter ramDisk is a pointer to a character array whose
//    size is equal to a 1.4 mb floppy disk (2849 � 512 bytes).
//	Return 0 for success, otherwise, return the error number
{
    FILE* fp;
    fp = fopen(fileName, "rb");
    if (fp)
    {
        fread(ramDisk, sizeof(char), SECTORS_PER_DISK * BYTES_PER_SECTOR, fp);
    }
    else return -1;
    fclose(fp);
    // copy FAT table to memory
    memcpy(FAT1, &RAMDisk[1 * BYTES_PER_SECTOR], NUM_FAT_SECTORS * BYTES_PER_SECTOR);
    memcpy(FAT2, &RAMDisk[10 * BYTES_PER_SECTOR], NUM_FAT_SECTORS * BYTES_PER_SECTOR);
    diskMounted = 1;				// disk has been mounted
    strcpy(dirPath, fileName);
    strcat(dirPath, ":\\");
    return 0;
} // end fmsMount



// ***************************************************************************************
// ***************************************************************************************
int fmsUnMount(char* fileName, void* ramDisk)
// Called by the unmount command.
// This function unloads your Project 5 RAM disk image to file computer file.
// The parameter fileName is the file path name of the disk image.
// The pointer parameter ramDisk points to a character array whose size is equal to a 1.4
// mb floppy disk (2849 � 512 bytes).
// Return 0 for success; otherwise, return the error number.
{
    diskMounted = 0;							// unmount disk
    // ?? add code here
    printf("\nfmsUnMount Not Implemented");

    return -1;
} // end fmsUnMount



// ***************************************************************************************
// ***************************************************************************************
int fmsReadSector(void* buffer, int sectorNumber)
//	Read into buffer RAM disk sector number sectorNumber.
// Sectors are 512 bytes.
//	Return 0 for success; otherwise, return an error number.
{
    memcpy(buffer, &RAMDisk[sectorNumber * BYTES_PER_SECTOR], BYTES_PER_SECTOR);
    ++sectorReads;
    return 0;
} // end fmsReadSector



// ***************************************************************************************
// ***************************************************************************************
int fmsWriteSector(void* buffer, int sectorNumber)
// Write 512 bytes from memory pointed to by buffer to RAM disk sector sectorNumber.
// Return 0 for success; otherwise, return an error number.
{
    memcpy(&RAMDisk[sectorNumber * BYTES_PER_SECTOR], buffer, BYTES_PER_SECTOR);
    ++sectorWrites;
    return 0;
} // end fmsWriteSector



// ***************************************************************************************
// Take a FAT table index and return an unsigned short containing the 12-bit FAT entry code
// ***************************************************************************************
void setFatEntry(int FATindex, unsigned short FAT12ClusEntryVal, unsigned char* FAT)
{
    int FATOffset = ((FATindex * 3) / 2);		// Calculate the offset
    int FATData = *((unsigned short*)&FAT[FATOffset]);
    FATData = BigEndian(FATData);
    if (FATindex % 2 == 0)						// If the index is even
    {	FAT12ClusEntryVal &= 0x0FFF;			// mask to 12 bits
        FATData &= 0xF000;							// mask complement
    }
    else												// Index is odd
    {	FAT12ClusEntryVal <<= 4; 				// move 12-bits high
        FATData &= 0x000F;						// mask complement
    }
    // Update FAT entry value in the FAT table
    FATData = BigEndian(FATData);
    *((unsigned short *)&FAT[FATOffset]) = FATData | FAT12ClusEntryVal;
    return;
} // End SetFatEntry



// ***************************************************************************************
// ***************************************************************************************
// Replace the 12-bit FAT entry code in the unsigned char FAT table at index
unsigned short getFatEntry(int FATindex, unsigned char* FATtable)
{
    unsigned short FATEntryCode;    			// The return value
    int FatOffset = ((FATindex * 3) / 2);	// Calculate the offset of the unsigned short to get
    if ((FATindex % 2) == 1)    				// If the index is odd
    {
        // Pull out a unsigned short from a unsigned char array
        FATEntryCode = *((unsigned short *)&FATtable[FatOffset]);
        FATEntryCode = BigEndian(FATEntryCode);
        FATEntryCode >>= 4;   					// Extract the high-order 12 bits
    }
    else												// If the index is even
    {
        // Pull out a unsigned short from a unsigned char array
        FATEntryCode = *((unsigned short *)&FATtable[FatOffset]);
        FATEntryCode = BigEndian(FATEntryCode);
        FATEntryCode &= 0x0fff;    			// Extract the low-order 12 bits
    }
    return FATEntryCode;
} // end GetFatEntry

// ***************************************************************************************
// ***************************************************************************************