/* $NetBSD: ahdilabel.c,v 1.12 2021/12/05 07:06:17 msaitoh Exp $ */

/*
* Copyright (c) 1999 The NetBSD Foundation, Inc.
* All rights reserved.
*
* This code is derived from software contributed to The NetBSD Foundation
* by Julian Coleman.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
*    notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
*    notice, this list of conditions and the following disclaimer in the
*    documentation and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
* ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
* BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*/

#include "privahdi.h"
#include <ctype.h>
#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <strings.h>

/*
* I think we can safely assume a fixed blocksize - AHDI won't support
* something different...
*/
#define BLPM            ((1024 * 1024) / DEV_BSIZE)
#define UNITS_SECTORS   0
#define UNITS_CTS       1
#define PART_ROOT       0
#define PART_START      1
#define PART_END        2

int              main (int, char*[]);
void             show_parts (struct ahdi_ptable*, int, int, int);
int              get_input (char *, int);
char            *sec_to_cts (struct ahdi_ptable*, u_int32_t, char *, size_t);
u_int32_t        read_sector (struct ahdi_ptable*, char *, int, int);
void             change_part (struct ahdi_ptable*, int, int);

int
main (int argc, char *argv[])
{
       struct ahdi_ptable      ptable;
       int                     flags, rv, key, units;

       if (argc < 2) {
               fprintf (stderr, "usage: %s raw_disk\n", argv[0]);
               exit (EXIT_FAILURE);
       }

       flags = AHDI_IGN_CKSUM;
       while ((rv = ahdi_readlabel(&ptable, argv[1], flags)) != 1) {
               switch (rv) {
               case -1:
                       fprintf (stderr,
                           "%s: %s: %s\n", argv[0], argv[1],
                           strerror (errno));
                       exit (EXIT_FAILURE);
                       break;
               case -2:
                       fprintf (stderr,
                           "%s: disk not 512 bytes/sector\n", argv[0]);
                       exit (EXIT_FAILURE);
                       break;
               case -3:
                       (void) fpurge(stdin);
                       printf ("No AHDI partitions found.  Continue (y/N)?");
                       if (toupper(getchar()) == 'Y') {
                               flags |= FORCE_AHDI;
                       } else
                               exit (EXIT_FAILURE);
                       break;
               case -4:
               case -5:
               case -6:
                       (void) fpurge(stdin);
                       printf ("Errors reading AHDI partition table.  Override (y/N)? ");
                       if (toupper(getchar()) == 'Y') {
                               flags |= AHDI_IGN_EXISTS | AHDI_IGN_EXT |
                                   AHDI_IGN_SPU;
                       } else
                               exit (EXIT_FAILURE);
                       break;
               case 1:
                       /* Everything is OK */
                       break;
               default:
                       exit (EXIT_FAILURE);
                       break;
               }
       }

       units = UNITS_SECTORS;
       flags = AHDI_KEEP_BOOT | AHDI_KEEP_BSL;
       show_parts (&ptable, 0, ptable.nparts, units);
       printf ("Preserve boot sector - ");
       flags & AHDI_KEEP_BOOT ? printf ("yes\n") :
           printf ("no\n");
       printf ("Preserve bad sector list - ");
       flags & AHDI_KEEP_BSL ? printf ("yes\n") :
           printf ("no\n");
       key = 0;
       while (key != 'Q') {
               (void) fpurge(stdin);
               printf ("Change [a-p], r)ecalculate, s)how, u)nits, w)rite, z)ero or q)uit ");
               key = toupper(getchar());
               if (key == EOF)
                       key = 'Q';
               if (key >= 'A' && key <= 'P')
                       change_part (&ptable, key - 'A', units);
               if (key == 'R') {
                       if (ahdi_buildlabel (&ptable)) {
                               printf ("Partition table adjusted\n");
                       } else {
                               printf ("No changes necessary\n");
                       }
               }
               if (key == 'S') {
                       show_parts (&ptable, 0, ptable.nparts, units);
                       printf ("Preserve boot sector - ");
                       flags & AHDI_KEEP_BOOT ? printf ("yes\n") :
                           printf ("no\n");
                       printf ("Preserve bad sector list - ");
                       flags & AHDI_KEEP_BSL ? printf ("yes\n") :
                           printf ("no\n");
               }
               if (key == 'U') {
                       if (units == UNITS_SECTORS) {
                               printf ("Units now cylinder/track/sector\n");
                               units = UNITS_CTS;
                       } else {
                               printf ("Units now sector\n");
                               units = UNITS_SECTORS;
                       }
               }
               if (key == 'W') {
                       if ((rv = ahdi_writelabel (&ptable, argv[1], flags)) < 0) {
                               if (rv == -1)
                                       perror ("\0");
                               if (rv == -2)
                                       printf ("Invalid number of partitions!\n");
                               if (rv == -3)
                                       printf ("GEM partition should be BGM or BGM partition should be GEM!\n");
                               if (rv == -4)
                                       printf ("Partition overlaps root sector or bad sector list (starts before sector 2)!\n");
                               if (rv == -5)
                                       printf ("Partition extends past end of disk!\n");
                               if (rv == -6)
                                       printf ("Partitions overlap!\n");
                               if (rv == -7)
                                       printf ("Partition overlaps auxiliary root!\n");
                               if (rv == -8)
                                       printf ("More than 4 partitions in root sector!\n");
                               if (rv == -9)
                                       printf ("More than 1 partition in an auxiliary root!\n");
                               if (rv < -1 && ahdi_errp1 != -1)
                                       printf ("\tpartition %c has errors.\n",
                                           ahdi_errp1 + 'a');
                               if (rv < -1 && ahdi_errp2 != -1)
                                       printf ("\tpartition %c has errors.\n",
                                           ahdi_errp2 + 'a');
                       }
               }
               if (key == 'Z') {
                       (void) fpurge(stdin);
                       printf ("Preserve boot sector? ");
                       if (flags & AHDI_KEEP_BOOT) {
                               printf ("[y] ");
                               if (toupper (getchar ()) == 'N')
                                       flags &= ~AHDI_KEEP_BOOT;
                       } else {
                               printf ("[n] ");
                               if (toupper (getchar ()) == 'Y')
                                       flags |= AHDI_KEEP_BOOT;
                       }
                       (void) fpurge(stdin);
                       printf ("Preserve bad sector list? ");
                       if (flags & AHDI_KEEP_BSL) {
                               printf ("[y] ");
                               if (toupper (getchar ()) == 'N')
                                       flags &= ~AHDI_KEEP_BSL;
                       } else {
                               printf ("[n] ");
                               if (toupper (getchar ()) == 'Y')
                                       flags |= AHDI_KEEP_BSL;
                       }
               }
       }
       return (0);
}

void
show_parts (struct ahdi_ptable *ptable, int start, int finish, int units)
{
       int     i;

       printf ("Disk information :\n");
       printf ("  sectors/track: %d\n", ptable->nsectors);
       printf ("  tracks/cylinder: %d\n", ptable->ntracks);
       printf ("  sectors/cylinder: %d\n", ptable->secpercyl);
       printf ("  cylinders: %d\n", ptable->ncylinders);
       printf ("  total sectors: %d\n", ptable->secperunit);

       if (units == UNITS_SECTORS) {
               printf ("  #  id      root     start       end      size   MBs\n");
               for (i = start; i < finish; i++) {
                       if (finish - start > 10 && i - start == 8) {
                               (void) fpurge(stdin);
                               printf ("-- Press return for more -- ");
                               (void) getchar();
                       }
                       printf ("  %c %c%c%c  %8u  %8u  %8u  %8u  (%4u)\n",
                           i + 'a', ptable->parts[i].id[0],
                           ptable->parts[i].id[1], ptable->parts[i].id[2],
                           ptable->parts[i].root, ptable->parts[i].start,
                           ptable->parts[i].start +
                           (ptable->parts[i].size ?
                           ptable->parts[i].size - 1 : 0),
                           ptable->parts[i].size,
                           (ptable->parts[i].size + (BLPM >> 1)) / BLPM);
               }
       } else {
               u_int32_t       cylinder, track, sector;
               printf ("  #  id          root         start           end          size    MBs\n");
               for (i = start; i < finish; i++) {
                       if (finish - start > 10 && i - start == 8) {
                               (void) fpurge(stdin);
                               printf ("-- Press return for more -- ");
                               (void) getchar();
                       }
                       printf ("  %c %c%c%c  ", i + 'a',
                           ptable->parts[i].id[0], ptable->parts[i].id[1],
                           ptable->parts[i].id[2]);
                       sector = ptable->parts[i].root;
                       cylinder = sector / ptable->secpercyl;
                       sector -= cylinder * ptable->secpercyl;
                       track = sector / ptable->nsectors;
                       sector -= track * ptable->nsectors;
                       printf ("%5u/%2u/%3u  ", cylinder, track, sector);
                       sector = ptable->parts[i].start;
                       cylinder = sector / ptable->secpercyl;
                       sector -= cylinder * ptable->secpercyl;
                       track = sector / ptable->nsectors;
                       sector -= track * ptable->nsectors;
                       printf ("%5u/%2u/%3u  ", cylinder, track, sector);
                       sector = ptable->parts[i].start +
                           (ptable->parts[i].size ?
                           ptable->parts[i].size - 1 : 0);
                       cylinder = sector / ptable->secpercyl;
                       sector -= cylinder * ptable->secpercyl;
                       track = sector / ptable->nsectors;
                       sector -= track * ptable->nsectors;
                       printf ("%5u/%2u/%3u  ", cylinder, track, sector);
                       sector = ptable->parts[i].size;
                       cylinder = sector / ptable->secpercyl;
                       sector -= cylinder * ptable->secpercyl;
                       track = sector / ptable->nsectors;
                       sector -= track * ptable->nsectors;
                       printf ("%5u/%2u/%3u   ", cylinder, track, sector);
                       printf ("(%4u)\n",
                           (ptable->parts[i].size + (BLPM >> 1)) / BLPM);
               }
       }
}

int
get_input (char *buf, int len)
{
       int count, key;

       count = 0;
       (void) fpurge(stdin);
       while (count < (len - 1) && (key = getchar()) != '\n' && key != '\r') {
               buf[count] = key;
               count++;
       }
       buf[count] = '\0';
       return(count);
}

char *
sec_to_cts (struct ahdi_ptable *ptable, u_int32_t sector, char *cts, size_t len)
{
       u_int32_t       cylinder, track;

       cylinder = sector / ptable->secpercyl;
       sector -= cylinder * ptable->secpercyl;
       track = sector / ptable->nsectors;
       sector -= track * ptable->nsectors;
       snprintf (cts, len, "%u/%u/%u", cylinder, track, sector);
       return (cts);
}

u_int32_t
read_sector (struct ahdi_ptable *ptable, char *buf, int part, int se)
{
       u_int32_t       sector, track, cylinder;
       int             i;

       sector = track = cylinder = 0;
       if ((strchr (buf, '/') != NULL) &&
           ((sscanf (buf, "%u/%u/%u", &cylinder, &track, &sector) == 3) ||
           (sscanf (buf, "%u/%u/", &cylinder, &track) == 2) ||
           (sscanf (buf, "%u/", &cylinder) == 1))) {
               if (sector > ptable->nsectors || track > ptable->ntracks ||
                   cylinder > ptable->ncylinders)
                       return (0);
               sector += ptable->nsectors * track;
               sector += ptable->secpercyl * cylinder;
               return (sector);
       }
       if (buf[0] == '-' && buf[1]) {
               if (buf[1] == '1' && se == PART_END)
                       /* Extend to end of disk */
                       return (ptable->secperunit -
                           ptable->parts[part].start);
               i = (int) (toupper ((unsigned char)(buf[1]) - 'A'));
               if (i >= 0 && i <= ptable->nparts ) {
                       if (se == PART_ROOT && part > i)
                               /* Root after partition ... */
                               return (ptable->parts[i].start +
                                   ptable->parts[i].size);
                       if (se == PART_START && part > i) {
                               /* Start after partition ... */
                               if (ptable->parts[part].root)
                                       return (ptable->parts[i].start +
                                           ptable->parts[i].size + 1);
                               else
                                       return (ptable->parts[i].start +
                                           ptable->parts[i].size);
                       }
                       if (se == PART_END && part < i)
                               /* End before partition ... */
                               return (ptable->parts[i].root -
                                   ptable->parts[part].start);
               }
               return (0);
       }
       if (sscanf (buf, "%u", &sector) == 1) {
               if (buf[strlen (buf) - 1] == 'm' ||
                   buf[strlen (buf) - 1] == 'M')
                       sector *= BLPM;
               return (sector);
       }
       return (0);
}

void
change_part (struct ahdi_ptable *ptable, int part, int units)
{
#define BUFLEN  20
#define CTSLEN  64
       char            buf[BUFLEN], cts[CTSLEN];
       u_int32_t       sector;

       if (part > ptable->nparts) {
               part = ptable->nparts;
               printf ("Changing partition %c!\n", part + 'a');
               ptable->nparts++;
       }
       if (part == ptable->nparts)
               ptable->nparts++;
       show_parts (ptable, part, part + 1, units);

       printf ("id [%c%c%c] ", ptable->parts[part].id[0],
           ptable->parts[part].id[1], ptable->parts[part].id[2]);
       if (get_input (&buf[0], BUFLEN) > 2) {
               ptable->parts[part].id[0] = buf[0];
               ptable->parts[part].id[1] = buf[1];
               ptable->parts[part].id[2] = buf[2];
       }

       printf ("root [%8u (%s)] ", ptable->parts[part].root,
           sec_to_cts (ptable, ptable->parts[part].root, cts, sizeof(cts)));
       if (get_input (&buf[0], BUFLEN)) {
               sector = read_sector (ptable, buf, part, PART_ROOT);
               ptable->parts[part].root = sector;
       }

       printf ("start [%8u (%s)] ", ptable->parts[part].start,
           sec_to_cts (ptable, ptable->parts[part].start, cts, sizeof(cts)));
       if (get_input (&buf[0], BUFLEN)) {
               sector = read_sector (ptable, buf, part, PART_START);
               ptable->parts[part].start = sector;
       }

       printf ("size [%8u (%s) (%4uM)] ", ptable->parts[part].size,
           sec_to_cts (ptable, ptable->parts[part].size, cts, sizeof(cts)),
           (ptable->parts[part].size + (BLPM >> 1)) / BLPM);
       if (get_input (&buf[0], BUFLEN)) {
               sector = read_sector (ptable, buf, part, PART_END);
               ptable->parts[part].size = sector;
       }

/*
       printf ("NetBSD disk letter [%c] ", ptable->parts[part].letter + 'a');
       if (get_input (&buf[0], BUFLEN)) {
               buf[0] = tolower(buf[0]);
               if (buf[0] == 'a' || (buf[0] >= 'd' && buf[0] <= 'p'))
                       ptable->parts[part].letter = buf[0] - 'a';
*/

       if (!ptable->parts[part].start && !ptable->parts[part].size) {
           if (part == ptable->nparts - 1)
               ptable->nparts--;
       }
}

You are viewing proxied material from ftp.icm.edu.pl. The copyright of proxied material belongs to its original authors. Any comments or complaints in relation to proxied material should be directed to the original authors of the content concerned. Please see the disclaimer for more details.