网上发现得一篇写磁盘扇区得文章（值得一看）

CODE:

/****************************************************************/
/*这是以前找工作的时候写的一个小程序, 可以将boot.img或dos.img等
烧到软盘或硬盘,只支持写FAT12和FAT16,而且有个bug,写太后面的磁
盘时会溢出.也懒的改了.                                                                                    */
/*                                                            */
/*                              test.c                                    */
/*                                                              */
/*              written by Liu Songling                                                                       */
/*                                                */
/*                        [e-mail]                */
/*                                                */
/*                            Match, 2006                */
/*                                                */
/*                                                */
/****************************************************************/

#include
#include
#include
#include
#include
#include
#include
#include
#include

/*
*        function for error
*/
void Error(int ErrorNum)
{
        if (ErrorNum == 0)
                fprintf(stderr,"Error opening source file\n");

        if (ErrorNum == 1)
                fprintf(stderr,"Error reading source file\n");

        if (ErrorNum == 2)
                fprintf(stderr,"Error accessing disk\n");

        if (ErrorNum == 3)
                fprintf(stderr,"Error writing disk\n");

        if (ErrorNum == 4)
                fprintf(stderr,"Error location the position,overflowed\n");

        if (ErrorNum == 5)
                fprintf(stderr,"I can not find the partion table,\
                Please fix it fist,or the source file could not been writing to your disk\n");

        if (ErrorNum == 6)
                fprintf(stderr,"This program only support FAT16\n");

        if (ErrorNum == 7)
                fprintf(stderr,"There is no such a disk\n");

        if (ErrorNum == 8)
                fprintf(stderr,"The source file is not a valid img file\n");

        if (ErrorNum == 9)
                fprintf(stderr,"I can not find any DOS partion\n");

        return ;
}
/*
*        function for help
*/
void help()
{
        printf("Usage:test \n");
        printf("Example:\n");
        printf("\ttest boot.img C\n");
        printf("Don not use C: or C:\\ etc\n");
        return ;
}
/*
*        PartionTable and DBR
*/
typedef struct
{
        char H8;
        char L8;
}WORD;

typedef struct
{
        char Head;
        char Sector;
        char CyL8;
}CHS;

typedef struct
{
        char BootFlag;
        CHS StartCHS;
        char SystemID;
        CHS EndCHS;
        long RelativeSectors;
        long TotalSectors;
}PartionTable;

typedef struct
{
        char H;
        char M;
        char L;
}JUMP;

typedef struct
{
        char ome[8];
}OME;

typedef struct
{
        int SectorBytes;
        char SectorPerCluster;
        int ReservedSectors;
        char NbrFat;
        int RootEntry;
        int TotalSectors;
        char Media;
        int SectorsPerFAT;
        int SectorsPerTrack;
        int Heads;
        long HiddenSectors;
        long BigTotalSectors;
}FAT16_BPB;

typedef struct
{
        char PhysicalDriverNumber;
        char CurrentHead;
        char ExtBootRecSign;
        long SerialNumber;
        char VollumeLabel[11];
        char FSID[8];
}EBPB;

typedef struct
{
        JUMP Jump;
        OME Ome;
        FAT16_BPB Bpb;
        EBPB EBpb;
        char BootCode[448];
        char EndCode[2];
}FAT16_DBR;


void main(int argc, char *argv[])
{
        int source = -1;

        int head = 0;
        long track = 0;
        long temp1 = 0;
        long temp2 = 0;
        int sector = 0;
        int driver = 0x80;
        int disk = 0;
        int file_size = 0;

        int i = 0;
        int j = 0;
        int decision = 0;
        int if_fat16 = 0;

        int SectorsPerTrack = 0;
        int HeadNum = 0;

        PartionTable *pts;
        FAT16_DBR *fat16_dbr;

        char read_buffer[512] = {0};
        char disk_buffer[512] = {0};
        char img_DBR[512] = {0};
        char disk_DBR[512] = {0};
        char file_type[8] = {"FAT16"};

/*
*        test whether command is correct
*/
        if (argc != 3)
        {
                help();
                return ;
        }

        if (strlen(argv[2]) != 1 || !strcmp(argv[2]," "))
        {
                help();
                return ;
        }

        disk = toupper(argv[2][0]) - 'C';

        if (disk < -2 || disk > 23)
        {
                Error(7);
                return ;
        }

        if ((source = open(argv[1], O_BINARY | O_RDONLY)) == -1)
        {
                Error(0);
                return ;
        }
/*
*        get the image file 's size
*/
        if ((file_size = filelength(source) / 512) != 2880)
        {
                Error(8);
                return ;
        }
/*
*        write floppy disk
*/
        if (disk == -2 || disk == -1)
        {
                if(biosdisk(2, disk+2, 1, 1, 1, 1, disk_buffer))
                {
                        Error(2);
                        return ;
                }
                else
                {
                        i = 0;
                        printf("writing disk,this will take you 1 or 2 minutes\n");
                        while(!eof(source))
                        {
                                if (read(source, read_buffer, sizeof(read_buffer)) <= 0)
                                {
                                        Error(1);
                                        return ;
                                }
                                else
                                {
                                        if(abswrite(disk+2, 1, i, read_buffer) == -1)
                                        {
                                                Error(3);
                                                return ;
                                        }
                                        i++;
                                }
                        }
                }
                close(source);
                return ;
        }
/*
*        get disk information
*/
        for(driver = 0x80; driver < 0xff; driver++)
        {
                if (!(biosdisk(2, driver, 0, 0, 1, 1, disk_buffer)) && \
                        (disk_buffer[510] == (char)0x55) && \
                        (disk_buffer[511] == (char)0xaa))
                        break;
        }
        if (driver == 0xff)
        {
                Error(2);
                return ;
        }

        pts = (PartionTable*)(&disk_buffer[446]);

        if (disk == 0)
        {
                for (i =0; i < 4 && i <= disk; i++)
                {
                        if ((pts[i].SystemID == 0x01) || (pts[i].SystemID == 0x04) || \
                                (pts[i].SystemID == 0x06) || (pts[i].SystemID == 0x0B) || \
                                (pts[i].SystemID == 0x0C) || (pts[i].SystemID == 0x0E))
                                break;
                }

                if (i == 4)
                {
                        Error(9);
                        return ;
                }
        }
        else
        {
                for(i = 0; i < 4; i++)
                {
                        if (pts[i].SystemID == 0x0F)
                                break;
                }
                if (i == 4)
                {
                        Error(9);
                        return ;
                }
        }
/*
*        locate the position
*/
        head = pts[i].StartCHS.Head;
        temp1 = 0x000000C0 & (pts[i].StartCHS.Sector);
        temp2 = 0x000000FF & (pts[i].StartCHS.CyL8);
        track = temp1 * 256 + temp2;
        sector = 0x003F & (pts[i].StartCHS.Sector);

        if (pts[i].SystemID == 0x04 || pts[i].SystemID == 0x06 || pts[i].SystemID == 0x0E)
                if_fat16 = 1;
        else
                if_fat16 = 0;
        if (pts[i].SystemID == 0x0F)
        {
                if (biosdisk(2, driver, head, track, sector, 1, disk_buffer))
                {
                        Error(2);
                        return ;
                }
                pts = (PartionTable *)(&disk_buffer[446]);

                while (disk > i)
                {
                        head = pts[1].StartCHS.Head;
                        temp1 = 0x000000C0 & (pts[1].StartCHS.Sector);
                        temp2 = 0x000000FF & (pts[1].StartCHS.CyL8);
                        track = temp1 * 256 + temp2;
                        sector = 0x003F & (pts[1].StartCHS.Sector);
                        if (biosdisk(2, driver, head, track, sector, 1, disk_buffer))
                        {
                                Error(2);
                                return ;
                        }
                        pts = (PartionTable *)(&disk_buffer[446]);
                        disk--;
                }

                head++;
                if((0x000000C0 & (pts[0].StartCHS.Sector)) *256 + \
                        (0x000000FF & (pts[0].StartCHS.CyL8)) <= 0)
                {
                        Error(4);
                        return ;
                }

                if(pts[0].SystemID == 0x04 || pts[0].SystemID == 0x06 || pts[0].SystemID == 0x0E)
                        if_fat16 = 1;
                else
                        if_fat16 = 0;

        }

        if(if_fat16 == 0)
        {
                Error(6);
                return ;
        }

        if (head <= 0 || track < 0 || sector <= 0)
        {
                Error(4);
                return ;
        }

        if (read(source, img_DBR, sizeof(img_DBR)) <= 0)
        {
                Error(1);
                return ;
        }

        if (biosdisk(2,driver,head,track,sector,1,disk_DBR))
        {
                Error(2);
                return ;
        }
/*
*        change disk DBR
*/
        disk_DBR[0x0B] = img_DBR[0x0B];
        disk_DBR[0x0C] = img_DBR[0x0C];
        disk_DBR[0x0D] = img_DBR[0x0D];
        disk_DBR[0x11] = img_DBR[0x11];
        disk_DBR[0x12] = img_DBR[0x12];
        disk_DBR[0x13] = img_DBR[0x13];
        disk_DBR[0x14] = img_DBR[0x14];
        disk_DBR[0x16] = img_DBR[0x16];
        disk_DBR[0x17] = img_DBR[0x17];
        disk_DBR[0x20] = img_DBR[0x20];
        disk_DBR[0x21] = img_DBR[0x21];
        disk_DBR[0x22] = img_DBR[0x22];
        disk_DBR[0x23] = img_DBR[0x23];
        disk_DBR[0x2B] = img_DBR[0x2B];
        disk_DBR[0x2C] = img_DBR[0x2C];
        disk_DBR[0x2D] = img_DBR[0x2D];
        disk_DBR[0x2E] = img_DBR[0x2E];
        disk_DBR[0x2F] = img_DBR[0x2F];
        disk_DBR[0x30] = img_DBR[0x30];
        disk_DBR[0x31] = img_DBR[0x31];
        disk_DBR[0x32] = img_DBR[0x32];
        disk_DBR[0x33] = img_DBR[0x33];
        disk_DBR[0x34] = img_DBR[0x34];
        disk_DBR[0x35] = img_DBR[0x35];

        for(i = 0; i < 8; i++)
        {
                disk_DBR[0x36+i] = file_type[i];
        }

        for(i = 0x3E,j = 0; i < 512 ; i++,j++)
        {
                disk_DBR[i] = img_DBR[i];
        }

        fat16_dbr =(FAT16_DBR *)(&disk_DBR[0]);
        SectorsPerTrack = (fat16_dbr->Bpb).SectorsPerTrack;
        HeadNum = (fat16_dbr->Bpb).Heads;

        if (SectorsPerTrack <= 0 || HeadNum <= 0)
        {
                Error(4);
                return ;
        }

        printf("If there would be an error,may be it would damage your disk\ncontinue?(N/Y)");

        decision = getchar();

        if (!(decision == 'Y' || decision == 'y'))
        {
                return ;
        }

        printf("writing disk,this will take 1 or 2 minutes\n");
/*
*        write the disk
*/
        if (biosdisk(3, driver, head, track, sector, 1, disk_DBR))
        {
                Error(3);
                return ;
        }

        sector++;

        while(!eof(source))
        {
                if (read(source, read_buffer, sizeof(read_buffer)) != 512)
                {
                        Error(1);
                        return ;
                }

                if (biosdisk(3, driver, head, track, sector, 1, read_buffer))
                {
                        Error(3);;
                        return ;
                }
                else
                {
                        sector++;
                        if(sector == SectorsPerTrack+1)
                        {
                                sector = 1;
                                head++;
                                if(head == HeadNum)
                                {
                                        track++;
                                        head = 0;
                                }
                        }

                }

        }

        if (source != -1)
                close(source);

        printf("\nwriting finished,please restart your computer\n\
        or maybe I can not find the directors\n");

        return ;
}