home *** CD-ROM | disk | FTP | other *** search
/ Chip 1998 February / CHIP_2_98.iso / misc / src / install / libfdisk / testfdisk.c < prev   
Encoding:
C/C++ Source or Header  |  1997-09-17  |  15.3 KB  |  619 lines
  1. /* test of the libfdisk library */
  2.  
  3. #include <stdio.h>
  4. #include <unistd.h>
  5. #include <stdlib.h>
  6. #include <string.h>
  7. #include <ctype.h>
  8. #include "libfdisk.h"
  9.  
  10.  
  11.  
  12. /* clean up that string */
  13. void TrimWhitespace( char *s ) {
  14.     char *f, *l, *p, *q;
  15.  
  16.     if (!(*s))
  17.         return;
  18.  
  19.     for (f=s; *f && isspace(*f); f++) ;
  20.  
  21.     if (!*f) {
  22.         *s = '\0';
  23.         return;
  24.     }
  25.  
  26.     for (l=f+strlen(f)-1; isspace(*l) ; l--)
  27.     *l = '\0';
  28.  
  29.     q = s, p = f;
  30.     while (*p)
  31.         *q++ = *p++;
  32.  
  33.     *q = '\0';
  34. } 
  35.  
  36. int ReadUnsigned( unsigned int *i ) {
  37.     char num[12];
  38.     char *eptr;
  39.     
  40.     fgets(num,12,stdin);
  41.     num[strlen(num)-1] = 0; /* blow the newline */
  42.     *i=strtol(num,&eptr,10);
  43.  
  44.     if (eptr != num && *eptr == 0)
  45.     return 0;
  46.     else
  47.     return FDISK_ERR_USERABORT;
  48. }
  49.  
  50. void ReadString( char **p ) {
  51.     char num[100];
  52.     
  53.     fgets(num,100,stdin);
  54.     num[strlen(num)-1] = 0; /* blow the newline */
  55.  
  56.     /* cleanup front, end whitespace */
  57.     TrimWhitespace( num );
  58.     
  59.     *p = (char *) malloc(strlen(num)+1);
  60.     strcpy(*p, num);
  61. }
  62.  
  63. int ReadBoolean( void ) {
  64.     char *str;
  65.     int  ret;
  66.     
  67.     ReadString(&str);
  68.     ret = (*str == 'Y' || *str == 'y');
  69.     free(str);
  70.     return ret;
  71. }
  72.     
  73. int ReadConstraint( char *name, Constraint *c, int required ) {
  74.     unsigned int v;
  75.  
  76.     printf("Requesting constraint for the parameter \"%s\":\n", name);
  77.     if (required)
  78.     printf("%s -> min value [required     ] :", name);
  79.     else
  80.     printf("%s -> min value [Enter to skip] :", name);
  81.     
  82.     if (ReadUnsigned(&v)) {
  83.     c->active  = 0;
  84.     c->min     = 0;
  85.     c->max     = 0;
  86.     c->current = 0;
  87.     return 1;
  88.     }
  89.  
  90.     c->min     = v;
  91.     c->active  = 1;
  92.  
  93. #if 0
  94.     printf("%s -> max value [Enter sets to min] :", name);
  95.     if (ReadUnsigned(&v))
  96.     c->max     = c->min;
  97.     else
  98.     c->max     = v;
  99. #endif
  100.  
  101.     return 0;
  102. }
  103.  
  104. void print_raw_partition_table_head( void ) {
  105.     printf("Nr AF  Hd Sec  Cyl  Hd Sec  Cyl   Start      Size    ID\n");
  106. }
  107.  
  108. void print_raw_partition_table(int num, RawPartitionTable *pt) {
  109.     int s_cyl, s_head, s_sector;
  110.     int e_cyl, e_head, e_sector;
  111.     unsigned int i;
  112.  
  113.     RawPartition *p;
  114.     
  115.     print_raw_partition_table_head();
  116.  
  117.     for (i=0; i<4; i++) {
  118.     p = &pt->entry[i];
  119.     
  120.     s_head    = p->start_head;
  121.     s_sector  = p->start_sec & 0x3f;
  122.     s_cyl     = ((unsigned int)(p->start_sec & 0xc0) << 2) + p->start_cyl;
  123.     
  124.     e_head    = p->end_head;
  125.     e_sector  = p->end_sec & 0x3f;
  126.     e_cyl     = ((unsigned int)(p->end_sec & 0xc0) << 2) + p->end_cyl;
  127.     
  128.     printf("%2d %2x %3d %3d %4d %3d %3d %4d %7d   %7d    %2x\n",
  129.            i+1, p->active, s_head, s_sector, s_cyl,
  130.            e_head, e_sector, e_cyl, p->start, p->size,
  131.            p->type);
  132.     }
  133. }
  134.  
  135. void print_user_partition_table(HardDrive *hd) {
  136.     int i;
  137.     Partition *up;
  138.     unsigned int first, last, end;
  139.     unsigned int s_cyl, s_hd, s_sec, e_cyl, e_hd, e_sec;
  140.  
  141.     
  142.     printf("Nr AF     Start C/H/S     End C/H/S      Start      Size    ID\n");
  143.  
  144.     /* print primary partitions first */
  145.     fdiskFirstPartition( hd, &first );
  146.     fdiskLastPartition( hd, &last );
  147.     for (i=first; i<=last; i++) {
  148.     up = &hd->table[i];
  149.     if (!(up->size.current) || !(up->type.current))
  150.         continue;
  151.  
  152.     fdiskSectorToCHS( hd, up->start.current, &s_cyl, &s_hd, &s_sec );
  153.     end = up->start.current + up->size.current - 1;
  154.     fdiskSectorToCHS( hd, end, &e_cyl, &e_hd, &e_sec );
  155.     printf("%2d %2x   [%4d/%3d/%3d]  [%4d/%3d/%3d] %7d   %7d    %2x\n",
  156.            up->num.current,
  157.            up->active.current,
  158.            s_cyl, s_hd, s_sec,
  159.            e_cyl, e_hd, e_sec,
  160.            up->start.current,
  161.            up->size.current,
  162.            up->type.current);
  163.     }
  164.  
  165. }
  166. void print_user_extended_partition_table(HardDrive *hd) {
  167.     int i;
  168.     Partition *up;
  169.     unsigned int last, end;
  170.     unsigned int s_cyl, s_hd, s_sec, e_cyl, e_hd, e_sec;
  171.  
  172.     printf("Nr AF     Start C/H/S     End C/H/S      Start      Size    ID\n");
  173.     if (!hd->pep) {
  174.     printf(" No  Extended Partitions Present\n");
  175.     return;
  176.     }
  177.     
  178.     /* print extended partitions only */
  179.     fdiskLastPartition( hd, &last );
  180.     for (i=hd->pep; i<=last; i++) {
  181.     if (i!=hd->pep)
  182.         up = &hd->eptable[i];
  183.     else
  184.         up = &hd->table[i];
  185.     
  186.     if (!(up->size.current) || !(up->type.current))
  187.         continue;
  188.  
  189.     fdiskSectorToCHS( hd, up->start.current, &s_cyl, &s_hd, &s_sec );
  190.     end = up->start.current + up->size.current - 1;
  191.     fdiskSectorToCHS( hd, end, &e_cyl, &e_hd, &e_sec );
  192.     printf("%2d %2x   [%4d/%3d/%3d]  [%4d/%3d/%3d] %7d   %7d    %2x\n",
  193.            up->num.current,
  194.            up->active.current,
  195.            s_cyl, s_hd, s_sec,
  196.            e_cyl, e_hd, e_sec,
  197.            up->start.current,
  198.            up->size.current,
  199.            up->type.current);
  200.  
  201.     /* make sure we move to first extended/logical pair */
  202.     if (i==hd->pep)
  203.         i = 4;
  204.     }
  205. }
  206.  
  207.  
  208. int print_used_spacemap( HardDrive *hd ) {
  209.     unsigned int i;
  210.     SpaceMap *map;
  211.     
  212.     fdiskUsedMapGen( hd, &map );
  213.  
  214.     printf("Number           Start        End         Size\n");
  215.     for (i=0; i < map->num; i++)
  216.     printf("   %d        %7d       %7d       %7d\n",
  217.            i,
  218.            map->entry[i].start,
  219.            map->entry[i].start+map->entry[i].size,
  220.            map->entry[i].size);
  221.  
  222.     fdiskSpaceMapFree( map );
  223.  
  224.     return 0;
  225. }
  226.  
  227. int print_free_spacemap( HardDrive *hd ) {
  228.     unsigned int i;
  229.     SpaceMap *map;
  230.     
  231.     fdiskFreeMapGen( hd, &map );
  232.  
  233.     printf("Number           Start        End         Size\n");
  234.     for (i=0; i < map->num; i++)
  235.     printf("   %d        %7d       %7d       %7d\n",
  236.            i,
  237.            map->entry[i].start,
  238.            map->entry[i].start+map->entry[i].size,
  239.            map->entry[i].size);
  240.  
  241.     fdiskSpaceMapFree( map );
  242.  
  243.     return 0;
  244. }
  245.  
  246. void print_partitionspec( PartitionSpec *spec ) {
  247.     unsigned int j;
  248.     unsigned int drive;
  249.     Partition   *p;
  250.     
  251.     printf("Requested partitions: \n\n");
  252.     printf("Mount Point  Num    Drive            Size          Endcyl     Weight   Status\n");
  253.     printf("-----------  ---  ----------    --------------   ----------   ------  ---------\n");
  254.  
  255.     for (j=0; j<spec->num; j++) {
  256.     p = &spec->entry[j].partition;
  257.     printf("%11s  ", spec->entry[j].name);
  258.  
  259.     printf("%2d   ",p->num.current);
  260.     
  261.     if (fdiskDriveSetIsActive(&p->drive)) {
  262.         fdiskInitWalkDriveSet(&p->drive,&drive);
  263.         printf("%2d", drive);
  264.         do {
  265.         printf(",%2d", drive);
  266.         } while (fdiskWalkDriveSet(&p->drive,&drive)==FDISK_SUCCESS);
  267.     } else
  268.         printf("Any Drive  ");
  269.  
  270.     if (p->size.active) {
  271.         printf("%8d", p->size.min);
  272.         if (p->size.max != p->size.min)
  273.         printf("+");
  274.         else
  275.         printf(" ");
  276.         printf("/%8d", p->size.current);
  277.     }else
  278.         printf("       Not Active      ");
  279.  
  280.     if (p->endcyl.active)
  281.         printf("  <= %5d  ", p->endcyl.max);
  282.     else
  283.         printf("  Not Active");
  284.  
  285.     printf("   %5d    ", fdiskGetConstraintPriority( p ));
  286.  
  287.     if (spec->entry[j].status == REQUEST_PENDING)
  288.         printf("PENDING");
  289.     else if (spec->entry[j].status == REQUEST_DENIED)
  290.         printf("DENIED");
  291.     else if (spec->entry[j].status == REQUEST_GRANTED)
  292.         printf("GRANTED");
  293.     else if (spec->entry[j].status == REQUEST_ORIGINAL)
  294.         printf("ORIGINAL");
  295.     else
  296.         printf("UNKNOWN");
  297.  
  298.     printf("\n");
  299.     }
  300. }
  301.  
  302. /* get user params and add a partition to the HardDrive hd     */
  303. /* new partition table stored on HardDrive nhd, and partition  */
  304. /* is added to the PartitionSpec spec                          */
  305. int TestAddPartition( HardDrive **hdarr, unsigned int numhd,
  306.               HardDrive **nhdarr, PartitionSpec *spec ) {
  307.     int status;
  308.     int num;
  309.     unsigned int temp;
  310.     char *name;
  311.     Constraint tempc;
  312.     Partition p;
  313.  
  314.     /* we read in a set of constaints for the desired partition */
  315.     /* from the user, then use the auto-allocation routines to  */
  316.     /* insert it into the current partition table.              */
  317.     /*                                                          */
  318.     num = spec->num;
  319.     if (num >= MAX_PARTITION_SPEC)
  320.     return FDISK_ERR_NOFREE;
  321.  
  322.     /* start from scratch */
  323.     memset(&p, 0, sizeof(Partition));
  324.  
  325.     /* get the desired name */
  326.     printf("Enter the mount point of the partition -> ");
  327.     ReadString( &name );
  328.     if (!*name)
  329.     return FDISK_ERR_NOFREE;
  330.  
  331.     /* We REQUIRE a size */
  332.     if (ReadConstraint("Size [in kilobytes]", &tempc, 1 )) {
  333.     printf("User aborted add.\n");
  334.     free(name);
  335.     return FDISK_ERR_USERABORT; /* they aborted */
  336.     }
  337.     temp = tempc.min*2;
  338.  
  339.     printf("Should partition be allowed to grow? ");
  340.     if (!ReadBoolean())
  341.     fdiskSetConstraint(&p.size, 0, temp, temp, 1);
  342.     else
  343.     fdiskSetConstraint(&p.size, 0, temp, FDISK_SIZE_MAX, 1);
  344.     
  345.     /* We REQUIRE a type */
  346.     if (ReadConstraint("Type", &tempc, 1 )) {
  347.     printf("User aborted add.\n");
  348.     free(name);
  349.     return FDISK_ERR_USERABORT; /* they aborted */
  350.     }
  351.     temp = tempc.min;
  352.     fdiskSetConstraint(&p.type, temp, temp, temp, 1);
  353.  
  354.     status = fdiskInsertPartitionSpec( spec, name, &p, REQUEST_PENDING );
  355.  
  356.     if (status == FDISK_SUCCESS) {
  357.     status = fdiskAutoInsertPartitions( hdarr, numhd, nhdarr, spec );
  358.     printf("Status of add was %d\n",status);
  359.     }
  360.  
  361.     free(name);
  362.     return status;
  363. }
  364.  
  365. /* edit partition specs, refresh table          */
  366. int TestEditPartition( HardDrive **hdarr, unsigned int numhd,
  367.                HardDrive **nhdarr, PartitionSpec *spec ) {
  368.     int status;
  369.     int num;
  370.     unsigned int temp;
  371.     char *name;
  372.     Constraint tempc;
  373.     Partition *p;
  374.  
  375.     if ((num=spec->num) == 0)
  376.     return FDISK_ERR_BADNUM;
  377.  
  378.     /* which should we change? */
  379.     printf("Enter mount point to edit [q to exit] ->");
  380.     ReadString( &name );
  381.     
  382.     if (!*name)
  383.     return FDISK_ERR_USERABORT;
  384.  
  385.     status = fdiskReturnPartitionSpec( spec, name, &p );
  386.     if (status != FDISK_SUCCESS)
  387.     return FDISK_ERR_BADNUM;
  388.  
  389.     if (p->immutable){
  390.     free(p);
  391.     return FDISK_ERR_BADNUM;
  392.     }
  393.     
  394.     /* let them them change size or type or growability */
  395.     /* We REQUIRE a size */
  396.     if (!ReadConstraint("Size [in kilobytes]", &tempc, 1 )) {
  397.     temp = tempc.min*2;
  398.     }
  399.  
  400.     printf("Should partition be allowed to grow? ");
  401.     if (!ReadBoolean())
  402.     fdiskSetConstraint(&p->size, 0, temp, temp, 1);
  403.     else
  404.     fdiskSetConstraint(&p->size, 0, temp, FDISK_SIZE_MAX, 1);
  405.     
  406.     /* We REQUIRE a type */
  407.     if (!ReadConstraint("Type", &tempc, 1 )) {
  408.     temp = tempc.min;
  409.     fdiskSetConstraint(&p->type, temp, temp, temp, 1);
  410.     }
  411.  
  412.     status = fdiskModifyPartitionSpec( spec, name, p, REQUEST_PENDING );
  413.     
  414.     if (status == FDISK_SUCCESS) {
  415.     status = fdiskAutoInsertPartitions( hdarr, numhd, nhdarr, spec );
  416.     printf("Status of add was %d\n",status);
  417.     }
  418.  
  419.     free(name);
  420.     free(p);
  421.     return status;
  422. }
  423.  
  424.  
  425. /* delete partition specs, refresh table          */
  426. int TestDeletePartition( HardDrive **hdarr, unsigned int numhd,
  427.              HardDrive **nhdarr, PartitionSpec *spec ) {
  428.     int status;
  429.     int num;
  430.     unsigned int c, l, m;
  431.     char *name;
  432.     Partition *p;
  433.  
  434.     if ((num=spec->num) == 0)
  435.     return FDISK_ERR_BADNUM;
  436.  
  437.     /* which should we change? */
  438.     printf("Enter mount point to delete [q to exit] -> ");
  439.     ReadString( &name );
  440.     
  441.     if (!*name)
  442.     return FDISK_ERR_USERABORT;
  443.  
  444.     status = fdiskReturnPartitionSpec( spec, name, &p );
  445.     if (status != FDISK_SUCCESS)
  446.     return FDISK_ERR_BADNUM;
  447.  
  448.     if (p->immutable) {
  449.     printf("Deleting a immutable partition (ok it sounds funny haha).\n");
  450.     fdiskGetCurrentConstraint(&p->num, &c);
  451.     fdiskGetCurrentDriveSet(&p->drive, &l);
  452.     for (m=0; m<numhd; m++)
  453.         if (hdarr[m]->num == l)
  454.         break;
  455.     
  456.     fdiskRemovePartition(hdarr[m], c);
  457.  
  458.     /* make it so we can delete this partition now */
  459.     p->immutable = 0;
  460.     fdiskModifyPartitionSpec( spec, name, p, REQUEST_PENDING );
  461.     }
  462.     
  463.     status = fdiskDeletePartitionSpec( spec, name );
  464.     
  465.     if (status == FDISK_SUCCESS) {
  466.     status = fdiskAutoInsertPartitions( hdarr, numhd, nhdarr, spec );
  467.     printf("Status of add was %d\n",status);
  468.     }
  469.  
  470.     free(name);
  471.     free(p);
  472.  
  473.     fdiskCleanOriginalSpecs( hdarr, numhd, spec );
  474.     return status;
  475. }
  476.  
  477.  
  478. int main(int argc, char **argv) {
  479.     int status;
  480.     int refresh;
  481.     int done;
  482.     
  483.     HardDrive       *ohd;          /* stores the original configuration    */
  484.     HardDrive       *hd;           /* stores current immutable partitions  */
  485.     HardDrive       *nhd;          /* stores current snapshot of everything*/
  486.     HardDrive       *thd;          /* tempoary snapshot used in updates    */
  487.     PartitionSpec   spec;          /* stores all the requested partitions  */
  488.  
  489.     if (argc < 2) {
  490.     fprintf(stderr, "Need to give a device name as argument.\n");
  491.     exit(1);
  492.     }
  493.     
  494.     status=fdiskOpenDevice(argv[1], 1, &ohd);
  495.     if (status < 0) {
  496.     perror("fdiskOpenDevice");
  497.     exit(1);
  498.     } else if (status > 0) {
  499.     fprintf(stderr,"fdiskOpendevice returns error %d\n",status);
  500.     exit(1);
  501.     } else
  502.     fprintf(stderr,"fdiskOpenDevice returns successfully\n");
  503.     
  504.  
  505.     status=fdiskReadPartitions(ohd);
  506.     if (status < 0) {
  507.     perror("fdiskReadPartitions");
  508.     exit(1);
  509.     } else if (status > 0) {
  510.     fprintf(stderr,"fdiskReadPartitions returns error %d\n",status);
  511.     exit(1);
  512.     } else
  513.     fprintf(stderr,"fdiskReadPartitions returns successfully.\n");
  514.  
  515.     /* copy harddrive data into working version */
  516.     hd = (HardDrive *) alloca(sizeof(HardDrive));
  517.     nhd = (HardDrive *) alloca(sizeof(HardDrive));
  518.     thd = (HardDrive *) alloca(sizeof(HardDrive));
  519.     memcpy(hd, ohd, sizeof(HardDrive));
  520.     memcpy(nhd, ohd, sizeof(HardDrive));
  521.     
  522.     /* setup original partitions */
  523.     fdiskSetupPartitionSpec( &hd, 1, &spec );
  524.     
  525.     /* ultra-simple fdisk program */
  526.     done = 0;
  527.     refresh = 1;
  528.  
  529.     while (!done) {
  530.     char cmd[5];
  531.  
  532.     if (refresh) {
  533.         printf("\nDrive %s: Geom  %d heads, %d sectors, %d cylinders\n",
  534.            hd->name,
  535.            hd->geom.heads, hd->geom.sectors, hd->geom.cylinders);
  536.         printf("Total number of sectors is %d\n",hd->totalsectors);
  537.  
  538.         printf("\nPartition Table is currently\n---------------\n");
  539.         print_user_partition_table(nhd);
  540.         printf("-----------------\nEnd of Table\n\n");
  541.         printf("\nExtended Partition Tables are currently\n");
  542.         printf("---------------------------------------\n\n");
  543.         print_user_extended_partition_table(nhd);
  544.         printf("-----------------\nEnd of Table\n\n");
  545.         print_partitionspec( &spec );
  546.         printf("\nUsed Space Map\n---------------\n\n");
  547.         print_used_spacemap(nhd);
  548.         printf("-----------------\nEnd of Table\n\n");
  549.         printf("\nFree Space Map\n---------------\n\n");
  550.         print_free_spacemap(nhd);
  551.         printf("-----------------\nEnd of Table\n\n");
  552.         refresh = 0;
  553.     }
  554.     
  555.         printf("[a]dd [d]elete [e]dit [p]rint [v]erify [w]rite [q]uit: ");
  556.     fgets(cmd, 5, stdin);
  557.  
  558.     switch (*cmd) {
  559.       case 'd':
  560.         memcpy(thd, hd, sizeof(HardDrive));
  561.         if (TestDeletePartition( &hd, 1, &thd, &spec ) == FDISK_SUCCESS) {
  562.         memcpy(nhd, thd, sizeof(HardDrive));
  563.         refresh = 1;
  564.         } else
  565.         printf("error deleting partition\n");
  566.         break;
  567.  
  568.       case 'p':
  569.         refresh = 1;
  570.         break;
  571.  
  572.       case 'a':
  573.         memcpy(thd, hd, sizeof(HardDrive));
  574.         if (TestAddPartition(&hd, 1, &thd, &spec) == FDISK_SUCCESS) {
  575.         memcpy(nhd, thd, sizeof(HardDrive));
  576.         refresh = 1;
  577.         } else
  578.         printf("error adding partition\n");
  579.         break;
  580.  
  581.       case 'e':
  582.         memcpy(thd, hd, sizeof(HardDrive));
  583.         if (TestEditPartition( &hd, 1, &thd, &spec ) == FDISK_SUCCESS) {
  584.         memcpy(nhd, thd, sizeof(HardDrive));
  585.         refresh = 1;
  586.         } else
  587.         printf("error editting partition\n");
  588.         break;
  589.  
  590.       case 'w':
  591.         fdiskWritePartitions( nhd );
  592.         break;
  593.  
  594.       case 'q':
  595.         done = 1;
  596.         break;
  597.  
  598.       default:
  599.         printf("Unknown command!\n");
  600.         break;
  601.     }
  602.  
  603.     }
  604.         
  605.  
  606.     status=fdiskCloseDevice(ohd);
  607.     if (status < 0) {
  608.     perror("fdiskCloseDevice");
  609.     exit(1);
  610.     } else if (status > 0) {
  611.     fprintf(stderr,"fdiskCloseDevice returns error %d\n",status);
  612.     exit(1);
  613.     } else
  614.     fprintf(stderr,"fdiskCloseDevice returns successfully\n");
  615.  
  616.     exit(0);
  617. }
  618.  
  619.