part_aux.c

独立 WIN98下磁盘分区程序（C语言＋汇编） 界面功能类似FDISK 但独立编译

#include "part.h"


void part_to_disk_addr(struct part_long *p,  unsigned long rel_sect,
                       struct disk_addr *daddr)
{
 unsigned long abs_sect;

 abs_sect = QUICK_BASE(p) + rel_sect;
 
 daddr->disk = dinfo.disk;
 daddr->cyl  = CYL(abs_sect);
 daddr->head = HEAD(abs_sect);
 daddr->sect = SECT(abs_sect);
}/* part_to_disk_addr */


int disk_read_rel(struct part_long *p, unsigned long rel_sect, void *buf, int num_sect)
{
 struct disk_addr daddr;
 
 part_to_disk_addr(p,rel_sect,&daddr);

 return disk_read( &daddr, buf, num_sect ); 
}/* disk_read_rel */


int disk_write_rel(struct part_long *p, unsigned long rel_sect, void *buf, int num_sect)
{
 struct disk_addr daddr;

 part_to_disk_addr(p,rel_sect,&daddr);

 return disk_write( &daddr, buf, num_sect ); 
}/* disk_write_rel */


void pack_part_tab(struct part_long *part, struct part_rec *part_rec, int n)
{
 int i;
 
 for( i=0 ; i<n ; i++ )
    {
     if( part[i].active==0 )
       {
        if( part_rec[i].boot_flag!=0 ) part_rec[i].boot_flag=0;
       }
     else
       {
        if( part_rec[i].boot_flag==0 ) part_rec[i].boot_flag=0x80;
       }

     part_rec[i].start_cylL = part[i].start_cyl & 0xFF;
     part_rec[i].start_cylH = part[i].start_cyl >> 8;
     part_rec[i].start_head = part[i].start_head;
     part_rec[i].start_sect = part[i].start_sect;

     part_rec[i].end_cylL   = part[i].end_cyl & 0xFF;
     part_rec[i].end_cylH   = part[i].end_cyl >> 8;
     part_rec[i].end_head   = part[i].end_head;
     part_rec[i].end_sect   = part[i].end_sect;

     part_rec[i].rel_sect   = part[i].rel_sect;
     part_rec[i].num_sect   = part[i].num_sect;

     part_rec[i].os_id  =  part[i].os_id >> 8;
    }
}/* pack_part_tab */


void unpack_part_tab(struct part_rec *part_rec, struct part_long *part, int n,
                                                struct part_long *container )
{
 int i;

 for( i=0 ; i<n ; i++ )
    {
     part[i].active = (part_rec[i].boot_flag==0)?0:1;

     part[i].start_cyl  = part_rec[i].start_cylL+(part_rec[i].start_cylH<<8);
     part[i].start_head = part_rec[i].start_head;
     part[i].start_sect = part_rec[i].start_sect;

     part[i].end_cyl    = part_rec[i].end_cylL+(part_rec[i].end_cylH<<8);
     part[i].end_head   = part_rec[i].end_head;
     part[i].end_sect   = part_rec[i].end_sect;

     part[i].rel_sect   = part_rec[i].rel_sect;
     part[i].num_sect   = part_rec[i].num_sect;

     part[i].os_id  =  part_rec[i].os_id << 8;

     if( i>0 && (part[i-1].os_id==0x8100 ||  /* Linix */
                 part[i-1].os_id==0x8300)  /* Linix ext2fs */
             && (part[i].os_id>>8)==0x82 /* Linix swap */ )
       {
        part[i].os_id=0x8201; /* Linux Swap */
       }

     determine_os_num( &part[i] );

     part[i].level = container->level+1;

     if( part[i].level>2 && part[i].os_id==OS_EXT )
        part[i].container = container->container;
     else
        part[i].container = container;

     part[i].container_base = QUICK_BASE(part[i].container);
    }
}/* unpack_part_tab */


void pack_adv_part_tab(struct part_long *part, struct adv_part_rec *part_rec, int n)
{
 int i;
 
 for( i=0 ; i<n ; i++ )
    {
     part_rec[i].os_id   =  part[i].os_id;
     part_rec[i].tag     =  part[i].active;
     part_rec[i].orig_row =  part[i].orig_row;

     part_rec[i].rel_sect = part[i].rel_sect;
     part_rec[i].num_sect = part[i].num_sect;
    }

}/* pack_adv_part_tab */




void unpack_adv_part_tab(struct adv_part_rec *part_rec, struct part_long *part,
                                                 int n, struct part_long *container )
{
 int i, mode = MODE_LBA;

 for( i=0 ; i<n ; i++ )
    {
     part[i].os_id    =   part_rec[i].os_id;
     part[i].active   =   part_rec[i].tag;
     part[i].orig_row  =  part_rec[i].orig_row;

     part[i].rel_sect   = part_rec[i].rel_sect;
     part[i].num_sect   = part_rec[i].num_sect;


     part[i].level = container->level+1;
     part[i].container = container;
     part[i].container_base = QUICK_BASE(container);

     recalculate_part(&part[i],mode);

     determine_os_num( &part[i] );
    }
  
}/* unpack_adv_part_tab */


void determine_os_num(struct part_long *p)
{
 int i=0;

 while( os_desc[i].os_id!=p->os_id && os_desc[i].os_id!=OS_UNKN ) i++;
 
 if( p->os_id==0xFF00 )
   {
    while( os_desc[i].os_id!=OS_HIDDEN ) i++;
   }
 
 p->os_num=i;
}/* determine_os_num */


void recalculate_part(struct part_long *p, int mode)
{
 unsigned long rel_sect, end_sect;

 if( mode==MODE_CHS )
   { 
    p->rel_sect=0;
    p->num_sect=0;

    if( p->start_sect!=0 )
      {
       rel_sect = ABS_REL_SECT(p);
       p->rel_sect = rel_sect - p->container_base;

       if( p->end_sect!=0 )
          {
           end_sect = ABS_END_SECT(p);
           if( end_sect >= rel_sect ) p->num_sect = end_sect - rel_sect + 1;
          }
      }
   }
 else /* mode==MODE_LBA */
   {
    p->start_cyl=0;	p->end_cyl=0;
    p->start_head=0;	p->end_head=0;
    p->start_sect=0;	p->end_sect=0;

    if( p->rel_sect!=0 || p->num_sect!=0 )
      {
       rel_sect = p->container_base + p->rel_sect;
       end_sect = p->container_base + p->rel_sect + p->num_sect - 1 ;

       p->start_cyl  = CYL(rel_sect);
       p->start_head = HEAD(rel_sect);
       p->start_sect = SECT(rel_sect);

       if( p->num_sect!=0 )
         {
          p->end_cyl  = CYL(end_sect);
          p->end_head = HEAD(end_sect);
          p->end_sect = SECT(end_sect);
         }
      }
   }/* LBA */

}/* recalculate_part */


int validate_table(struct part_long *part, int n, struct part_long *container2)
{
 int i, j;
 struct part_long *p, *q;
 struct part_long *container;
 unsigned long rel_sect, end_sect, num_sect;

 for( p=part, i=0 ; i<n ; i++, p++ )
    {
     p->empty=1;

          if( p->start_cyl!=0  ) p->empty=0;
     else if( p->start_head!=0 ) p->empty=0;
     else if( p->start_sect!=0 ) p->empty=0;

     else if( p->end_cyl!=0  ) p->empty=0;
     else if( p->end_head!=0 ) p->empty=0;
     else if( p->end_sect!=0 ) p->empty=0;

     else if( p->rel_sect!=0 ) p->empty=0;
     else if( p->num_sect!=0 ) p->empty=0;
    }


 for(  p=part, i=0 ; i<n ; i++, p++ )
    {
     if( p->empty ) continue;
     
     p->valid=1;
     p->mbr_err=0;
     p->range_err=0;
     p->overlap_err=0;
     p->inconsist_err=0;
     p->boot_record_err=0;

     container = p->container;
     
     rel_sect = ABS_REL_SECT(p);

     end_sect = ABS_END_SECT(p);
     
     num_sect = end_sect - rel_sect + 1;

     if( rel_sect != p->rel_sect+p->container_base ) p->inconsist_err=1;
     if( num_sect != p->num_sect                   ) p->inconsist_err=1;

     if( mode==MODE_CHS )
       {
             if( p->end_cyl <  p->start_cyl ) p->range_err=1;
        else if( p->end_cyl == p->start_cyl && p->end_head <  p->start_head  ) p->range_err=1;
        else if( p->end_cyl == p->start_cyl && p->end_head == p->start_head && p->end_sect < p->start_sect ) p->range_err=1;

             if( p->end_cyl >  container->end_cyl ) p->range_err=1;
        else if( p->end_cyl == container->end_cyl && p->end_head >  container->end_head ) p->range_err=1;
        else if( p->end_cyl == container->end_cyl && p->end_head == container->end_head && p->end_sect > container->end_sect ) p->range_err=1;

             if( p->start_cyl <  container->start_cyl ) p->range_err=1;
        else if( p->start_cyl == container->start_cyl && p->start_head <  container->start_head ) p->range_err=1;
        else if( p->start_cyl == container->start_cyl && p->start_head == container->start_head && p->start_sect < container->start_sect ) p->range_err=1;
        
        if( p->start_cyl >= dinfo.num_cyls ) p->range_err=1;
        if( p->end_cyl   >= dinfo.num_cyls ) p->range_err=1;
        
        if( p->start_head >= dinfo.num_heads ) p->range_err=1;
        if( p->end_head   >= dinfo.num_heads ) p->range_err=1;

        if( p->start_sect >  dinfo.num_sects ) p->range_err=1;
        if( p->end_sect   >  dinfo.num_sects ) p->range_err=1;

        if( p->start_sect == 0 ) p->range_err=1;
        if( p->end_sect   == 0 ) p->range_err=1;

        if( p->start_cyl  == container->start_cyl &&
            p->start_head == container->start_head &&
            p->start_sect == container->start_sect ) p->mbr_err=1;
       }
     else /* mode==MODE_LBA */
       {
        if( p->rel_sect == 0 ) p->mbr_err=1;
        if( p->rel_sect >= container->num_sect ) p->range_err=1;
        if( p->num_sect - 1 > container->num_sect ) p->range_err=1;
        if( p->rel_sect + p->num_sect - 1 >= container->num_sect ) p->range_err=1;

        rel_sect=p->rel_sect + p->container_base;
        end_sect=rel_sect + p->num_sect - 1 ;
       }

     for( q=part, j=0 ; j<n ; j++, q++ )
        {
         unsigned long q_rel_sect, q_end_sect;
         
         if( i==j || q->empty ) continue;
         
         q_rel_sect = (mode==MODE_CHS) ? ABS_REL_SECT(q) : (q->rel_sect + q->container_base);
         q_end_sect = (mode==MODE_CHS) ? ABS_END_SECT(q) : (q_rel_sect + q->num_sect - 1);
         
         if( rel_sect >= q_rel_sect && rel_sect <= q_end_sect ) p->overlap_err=1;
         if( q_rel_sect >= rel_sect && q_rel_sect <= end_sect ) p->overlap_err=1;
        }/* q */
     
     if( p->mbr_err || p->range_err || p->overlap_err || p->inconsist_err ) p->valid=0;
    }/* p */

 for( i=0 ; i<n ; i++ )
  if( container2->level>1 && part[i].os_id==OS_EXT &&
      part[i].start_cyl < container2->end_cyl+1 )
     {
      part[i].range_err=1;
      part[i].valid=0;
     }

 for( i=0 ; i<n ; i++ )
  if( part[i].empty==0 && part[i].valid==0 )
     return 0;

 return 1;
}/* validate_table */



int write_int(int attr, int x, int y, int w, unsigned long xx)
{
 char tmp[30];
 
 sprintf(tmp,"%*ld",w,xx);
 write_string(attr,x,y,tmp);
 
 return 0;
}/* write_int */


char *sprintf_long(char *tmp, unsigned long num)