Subversion Repositories SvarDOS

/*

 * SVARDOS INSTALL PROGRAM

 *

 * PUBLISHED UNDER THE TERMS OF THE MIT LICENSE

 *

 * COPYRIGHT (C) 2016-2024 MATEUSZ VISTE, ALL RIGHTS RESERVED.

 *

 * Permission is hereby granted, free of charge, to any person obtaining a

 * copy of this software and associated documentation files (the "Software"),

 * to deal in the Software without restriction, including without limitation

 * the rights to use, copy, modify, merge, publish, distribute, sublicense,

 * and/or sell copies of the Software, and to permit persons to whom the

 * Software is furnished to do so, subject to the following conditions:

 *

 * The above copyright notice and this permission notice shall be included in

 * all copies or substantial portions of the Software.

 *

 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR

 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,

 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE

 * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER

 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING

 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER

 * DEALINGS IN THE SOFTWARE.

 *

 * http://svardos.org

 */

#include <dos.h>

#include <direct.h>  /* mkdir() */

#include <stdio.h>   /* printf() and friends */

#include <stdlib.h>  /* system() */

#include <string.h>  /* memcpy() */

#include <unistd.h>

#include "mdr\cout.h"

#include "mdr\dos.h"

#include "svarlang.lib\svarlang.h"

/* keyboard layouts and locales */

#include "keylay.h"

#include "keyoff.h"

/* color scheme (preset for color) */

static unsigned char COLOR_TITLEBAR  = 0x70;

static unsigned char COLOR_TITLEVER  = 0x78;

static unsigned char COLOR_BODY      = 0x17;

static unsigned char COLOR_BODYWARN  = 0x1F;

static unsigned char COLOR_SELECT    = 0x70;

static unsigned char COLOR_SELECTCUR = 0x1F;

/* build release string, populated at startup by reading floppy's label */

static char BUILDSTRING[13];

/* how much disk space does SvarDOS require (in MiB) */

#define SVARDOS_DISK_REQ 4

/* menu screens can output only one of these: */

#define MENUNEXT 0

#define MENUPREV -1

#define MENUQUIT -2

/* a convenience 'function' used for debugging */

#define DBG(x) { video_putstringfix(24, 0, 0x4F00u, x, 80); }

struct slocales {

  char lang[4];

  const char *keybcode;

  unsigned short codepage;

  unsigned char egafile;

  unsigned char keybfile;

  short keyboff;

  short keyblen;

  unsigned short keybid;

  unsigned short countryid; /* 1=USA, 33=FR, 48=PL, etc */

};

/* returns the DOS boot drive letter ('A', 'B', 'C', etc) */

static unsigned char GETDOSBOOTDRIVE(void);

#pragma aux GETDOSBOOTDRIVE = \

"mov ax, 0x3305" /* int 0x21,AX=3305 - get boot drive (MS-DOS 4.0+) */ \

"int 0x21" \

"jnc GOOD" \

"mov dl, 3"      /* fall back to "C" on error (DOS 3.x...) */ \

"GOOD:" \

"add dl, '@'"    /* convert the drive id (A=1, B=2...) into a drive letter */ \

modify [ax] \

value [dl]

/* install a dummy int24h handler that always fails. this is to avoid the

 * annoying "abort, retry, fail... DOS messages. */

static void install_int24(void) {

  static unsigned char handler[] = { /* contains machine code instructions */

    0xB0, 0x03,  /* mov al, 3   ; tell DOS the action has to FAIL   */

    0xCF};       /* ret         ; return from the interrupt handler */

  /* install the handler */

  _asm {

    push dx

    mov ax, 0x2524          /* set INT vector 0x24 (to DS:DX)   */

    mov dx, offset handler  /* DS:DX points at my dummy handler */

    int 0x21

    pop dx

  }

}

static void exec(const char *s) {

  system(s);

  install_int24(); /* reinstall my int24 handler, apparently system() reverts

                      the original (DOS) one */

}

/* put a string on screen and fill it until w chars with white space */

static void video_putstringfix(unsigned char y, unsigned char x, unsigned char attr, const char *s, unsigned char w) {

  unsigned char i;

  /* print the string up to w characters */

  i = mdr_cout_str(y, x, s, attr, w);

  /* fill in left space (if any) with blanks */

  mdr_cout_char_rep(y, x + i, ' ', attr, w - i);

}

/* reboot the computer */

static void reboot(void) {

  void ((far *bootroutine)()) = (void (far *)()) 0xFFFF0000L;

  int far *rstaddr = (int far *)0x00400072L; /* BIOS boot flag is at 0040:0072 */

  *rstaddr = 0x1234; /* 0x1234 = warm boot, 0 = cold boot */

  (*bootroutine)(); /* jump to the BIOS reboot routine at FFFF:0000 */

}

/* returns 1 if file exists, zero otherwise */

static int fileexists(const char *fname) {

  FILE *fd;

  fd = fopen(fname, "rb");

  if (fd == NULL) return(0);

  fclose(fd);

  return(1);

}

/* outputs a string to screen with taking care of word wrapping. returns amount of lines. */

static unsigned char putstringwrap(unsigned char y, unsigned char x, unsigned char attr, const char *s) {

  unsigned char linew, lincount;

  linew = 80 - (x << 1);

  for (lincount = 1; y+lincount < 25; lincount++) {

    int i, len = linew;

    for (i = 0; i <= linew; i++) {

      if (s[i] == ' ') len = i;

      if (s[i] == '\n') {

        len = i;

        break;

      }

      if (s[i] == 0) {

        len = i;

        break;

      }

    }

    mdr_cout_str(y++, x, s, attr, len);

    s += len;

    if (*s == 0) break;

    s += 1; /* skip the whitespace char */

  }

  return(lincount);

}

/* an NLS wrapper around video_putstring(), also performs line wrapping when

 * needed. returns the amount of lines that were output */

static unsigned char putstringnls(unsigned char y, unsigned char x, unsigned char attr, unsigned char nlsmaj, unsigned char nlsmin) {

  const char *s = svarlang_str(nlsmaj, nlsmin);

  if (s == NULL) s = "";

  return(putstringwrap(y, x, attr, s));

}

/* copy file f1 to f2 using buff as a buffer of buffsz bytes. f2 will be overwritten if it

 * exists already! returns 0 on success. */

static int fcopy(const char *f2, const char *f1, void *buff, size_t buffsz) {

  FILE *fd1, *fd2;

  size_t sz;

  int res = -1; /* assume failure */

  /* open files */

  fd1 = fopen(f1, "rb");

  fd2 = fopen(f2, "wb");

  if ((fd1 == NULL) || (fd2 == NULL)) goto QUIT;

  /* copy data */

  for (;;) {

    sz = fread(buff, 1, buffsz, fd1);

    if (sz == 0) {

      if (feof(fd1) != 0) break;

      goto QUIT;

    }

    if (fwrite(buff, 1, sz, fd2) != sz) goto QUIT;

  }

  res = 0; /* success */

  QUIT:

  if (fd1 != NULL) fclose(fd1);

  if (fd2 != NULL) fclose(fd2);

  return(res);

}

/* display a menu with items and return user's choice.

 * ypos: starting line where the menu is drawn

 * height: number of items to display inside the menu

 * list: NULL-terminated list of items

 * maxlistlen: limit list to this many items tops */

static int menuselect(unsigned char ypos, unsigned char height, const char **list, int maxlistlen) {

  int i, offset = 0, res = 0, count;

  unsigned char y, xpos, width = 0;

  /* count how many positions there are, and check their width */

  for (count = 0; (list[count] != NULL) && (count != maxlistlen); count++) {

    int len = strlen(list[count]);

    if (len > width) width = len;

  }

  width++; /* it's nice to have a small margin to the right of the widest item */

  /* if xpos negative, means 'center out' */

  xpos = 39 - (width >> 1);

  mdr_cout_char_rep(ypos, xpos, 0xC4, COLOR_SELECT, width + 2);  /* top line */

  mdr_cout_char(ypos, xpos+width+2, 0xBF, COLOR_SELECT);         /*       \ */

  mdr_cout_char(ypos, xpos-1, 0xDA, COLOR_SELECT);               /*  /      */

  ypos++; /* from now on ypos relates to the position of the content */

  mdr_cout_char(ypos+height, xpos-1, 0xC0, COLOR_SELECT);      /*  \      */

  mdr_cout_char(ypos+height, xpos+width+2, 0xD9, COLOR_SELECT);/*      /  */

  mdr_cout_char_rep(ypos+height, xpos, 0xC4, COLOR_SELECT, width + 2);

  for (;;) {

    int key;

    /* draw side borders of the menu + the cursor */

    if (count <= height) { /* no need for a cursor, all fits on one page */

      i = 255;

    } else {

      i = offset * (height - 1) / (count - height);

    }

    for (y = ypos; y < (ypos + height); y++) {

      mdr_cout_char(y, xpos-1, 0xB3, COLOR_SELECT); /* left side */

      if (y - ypos == i) {

        mdr_cout_char(y, xpos+width+2, '=', COLOR_SELECT); /* cursor */

      } else {

        mdr_cout_char(y, xpos+width+2, 0xB3, COLOR_SELECT); /* right side */

      }

    }

    /* list of selectable items */

    for (i = 0; i < height; i++) {

      if (i + offset == res) {

        mdr_cout_char(ypos + i, xpos, 16, COLOR_SELECTCUR);

        mdr_cout_char(ypos + i, xpos+width+1, 17, COLOR_SELECTCUR);

        mdr_cout_locate(ypos + i, xpos);

        video_putstringfix(ypos + i, xpos+1, COLOR_SELECTCUR, list[i + offset], width);

      } else if (i + offset < count) {

        mdr_cout_char(ypos + i, xpos, ' ', COLOR_SELECT);

        mdr_cout_char(ypos + i, xpos+width+1, ' ', COLOR_SELECT);

        video_putstringfix(ypos + i, xpos+1, COLOR_SELECT, list[i + offset], width);

      } else {

        mdr_cout_char_rep(ypos + i, xpos, ' ', COLOR_SELECT, width+2);

      }

    }

    key = mdr_dos_getkey();

    if (key == 0x0D) { /* ENTER */

      return(res);

    } else if (key == 0x148) { /* up */

      if (res > 0) {

        res--;

        if (res < offset) offset = res;

      }

    } else if (key == 0x150) { /* down */

      if (res+1 < count) {

        res++;

        if (res > offset + height - 1) offset = res - (height - 1);

      }

    } else if (key == 0x147) { /* home */

      res = 0;

      offset = 0;

    } else if (key == 0x14F) { /* end */

      res = count - 1;

      if (res > offset + height - 1) offset = res - (height - 1);

    } else if (key == 0x1B) {  /* ESC */

      return(-1);

    }/* else {

      char buf[8];

      snprintf(buf, sizeof(buf), "0x%02X ", key);

      video_putstring(1, 0, COLOR_BODY, buf, -1);

    }*/

  }

}

static void newscreen(unsigned char statusbartype) {

  const char *msg;

  mdr_cout_cls(COLOR_BODY);

  msg = svarlang_strid(0x00); /* "SVARDOS INSTALLATION" */

  mdr_cout_char_rep(0, 0, ' ', COLOR_TITLEBAR, 80);

  mdr_cout_str(0, 40 - (strlen(msg) >> 1), msg, COLOR_TITLEBAR, 80);

  mdr_cout_str(0, 80 - strlen(BUILDSTRING), BUILDSTRING, COLOR_TITLEVER, 12);

  switch (statusbartype) {

    case 1:

      msg = svarlang_strid(0x000B); /* "Up/Down = Select entry | Enter = Validate your choice | ESC = Quit to DOS" */

      break;

    case 2:

      msg = svarlang_strid(0x0005); /* "Press any key..." */

      break;

    case 3:

      msg = "";

      break;

    default:

      msg = svarlang_strid(0x000A); /* "Up/Down = Select entry | Enter = Validate your choice | ESC = Previous screen" */

      break;

  }

  mdr_cout_char(24, 0, ' ', COLOR_TITLEBAR);

  video_putstringfix(24, 1, COLOR_TITLEBAR, msg, 79);

  mdr_cout_locate(25,0);

}

/* fills a slocales struct accordingly to the value of its keyboff member */

static void kblay2slocal(struct slocales *locales) {

  const char *m;

  for (m = kblayouts[locales->keyboff]; *m != 0; m++); /* skip layout name */

  m++;

  /* skip keyb code and copy it to locales.keybcode */

  locales->keybcode = m;

  for (; *m != 0; m++);

  /* */

  locales->codepage = ((unsigned short)m[1] << 8) | m[2];

  locales->egafile = m[3];

  locales->keybfile = m[4];

  locales->keybid = ((unsigned short)m[5] << 8) | m[6];

  locales->countryid = ((unsigned short)m[7] << 8) | m[8];

}

static int selectlang(struct slocales *locales) {

  int choice, x;

  const char *msg;

  const char *langlist[] = {

    "English",

    "Brazilian",

    "French",

    "German",

    "Italian",

    "Polish",

    "Russian",

    "Slovene",

    "Swedish",

    "Turkish",

    NULL

  };

  newscreen(1);

  msg = svarlang_strid(0x0100); /* "Welcome to SvarDOS" */

  x = 40 - (strlen(msg) >> 1);

  mdr_cout_str(4, x, msg, COLOR_BODY, 80);

  mdr_cout_char_rep(5, x, '=', COLOR_BODY, strlen(msg));

  /* center out the string "Please select your language..." */

  msg = svarlang_str(1, 1); /* "Please select your language from the list below:" */

  if (strlen(msg) > 74) {

    putstringwrap(8, 1, COLOR_BODY, msg);

  } else {

    mdr_cout_str(8, 40 - (strlen(msg) / 2), msg, COLOR_BODY, 80);

  }

  choice = menuselect(11, 9, langlist, -1);

  if (choice < 0) return(MENUPREV);

  /* populate locales with default values */

  memset(locales, 0, sizeof(struct slocales));

  switch (choice) {

    case 1:

      strcpy(locales->lang, "BR");

      locales->keyboff = OFFLOC_BR;

      locales->keyblen = OFFLEN_BR;

      break;

    case 2:

      strcpy(locales->lang, "FR");

      locales->keyboff = OFFLOC_FR;

      locales->keyblen = OFFLEN_FR;

      break;

    case 3:

      strcpy(locales->lang, "DE");

      locales->keyboff = OFFLOC_DE;

      locales->keyblen = OFFLEN_DE;

      break;

    case 4:

      strcpy(locales->lang, "IT");

      locales->keyboff = OFFLOC_IT;

      locales->keyblen = OFFLEN_IT;

      break;

    case 5:

      strcpy(locales->lang, "PL");

      locales->keyboff = OFFLOC_PL;

      locales->keyblen = OFFLEN_PL;

      break;

    case 6:

      strcpy(locales->lang, "RU");

      locales->keyboff = OFFLOC_RU;

      locales->keyblen = OFFLEN_RU;

      break;

    case 7:

      strcpy(locales->lang, "SI");

      locales->keyboff = OFFLOC_SI;

      locales->keyblen = OFFLEN_SI;

      break;

    case 8:

      strcpy(locales->lang, "SV");

      locales->keyboff = OFFLOC_SV;

      locales->keyblen = OFFLEN_SV;

      break;

    case 9:

      strcpy(locales->lang, "TR");

      locales->keyboff = OFFLOC_TR;

      locales->keyblen = OFFLEN_TR;

      break;

    default:

      strcpy(locales->lang, "EN");

      locales->keyboff = 0;

      locales->keyblen = OFFCOUNT;

      break;

  }

  /* populate the slocales struct accordingly to the keyboff member */

  kblay2slocal(locales);

  /* */

  return(MENUNEXT);

}

static int selectkeyb(struct slocales *locales) {

  int menuheight, choice;

  if (locales->keyblen == 1) return(MENUNEXT); /* do not ask for keyboard layout if only one is available for given language */

  newscreen(0);

  putstringnls(5, 1, COLOR_BODY, 1, 5); /* "SvarDOS supports different keyboard layouts */

  menuheight = locales->keyblen;

  if (menuheight > 11) menuheight = 11;

  choice = menuselect(10, menuheight, &(kblayouts[locales->keyboff]), locales->keyblen);

  if (choice < 0) return(MENUPREV);

  /* (re)load the keyboard layout & codepage setup */

  locales->keyboff += choice;

  kblay2slocal(locales);

  return(MENUNEXT);

}

/* returns 0 if installation must proceed, non-zero otherwise */

static int welcomescreen(void) {

  int c;

  const char *choice[3];

  choice[0] = svarlang_strid(0x0001);

  choice[1] = svarlang_strid(0x0002);

  choice[2] = NULL;

  newscreen(0);

  putstringnls(4, 1, COLOR_BODY, 2, 0); /* "You are about to install SvarDOS */

  c = menuselect(13, 2, choice, -1);

  if (c < 0) return(MENUPREV);

  if (c == 0) return(MENUNEXT);

  return(MENUQUIT);

}

/* returns 0 if drive is removable, 1 if fixed, -1 on error */

static int isdriveremovable(unsigned char drv);

#pragma aux isdriveremovable = \

"mov ax, 0x4408" \

"int 0x21" \

"jnc DONE" \

"xor ax,ax" \

"dec ax" \

"DONE:" \

parm [bl] \

value [ax]

/* returns total disk space of drive drv (in MiB, max 2048, A=1 B=2 etc), or -1 if drive invalid */

static int disksize(unsigned char drv) {

  unsigned short sec_per_cluster = 0;

  unsigned short tot_clusters = 0;

  unsigned short bytes_per_sec = 0;

  long res;

  _asm {

    push ax

    push bx

    push cx

    push dx

    mov ah, 0x36

    mov dl, drv

    int 0x21

    /* AX=sec_per_cluster DX=tot_clusters BX=free_clusters CX=bytes_per_sec */

    mov sec_per_cluster, ax

    mov bytes_per_sec, cx

    mov tot_clusters, dx

    pop dx

    pop cx

    pop bx

    pop ax

  }

  if (sec_per_cluster == 0xffff) return(-1);

  res = sec_per_cluster;

  res *= tot_clusters;

  res *= bytes_per_sec;

  res >>= 20;

  return((int)res);

}

/* returns 0 if disk is empty, non-zero otherwise */

static int diskempty(char drv) {

  unsigned int rc;

  int res;

  char buff[8];

  struct find_t fileinfo;

  snprintf(buff, sizeof(buff), "%c:\\*.*", drv);

  rc = _dos_findfirst(buff, _A_NORMAL | _A_SUBDIR | _A_HIDDEN | _A_SYSTEM, &fileinfo);

  if (rc == 0) {

    res = 1; /* call successfull means disk is not empty */

  } else {

    res = 0;

  }

  /* _dos_findclose(&fileinfo); */ /* apparently required only on OS/2 */

  return(res);

}

/* get the DOS "current drive" (0=A:, 1=B:, etc) */

static unsigned char get_cur_drive(void);

#pragma aux get_cur_drive = \

"mov ah, 0x19" /* DOS 1+ GET CURRENT DEFAULT DRIVE */ \

"int 0x21" \

modify [ah] \

value [al]

/* replace all occurences of char a by char b in s */

static void strtr(char *s, char a, char b) {

  for (;*s != 0; s++) {

    if (*s == a) *s = b;

  }

}

/* tries to write an empty file to drive.

 * asks DOS to inhibit the int 24h handler for this job, so erros are

 * gracefully reported - unfortunately this does not work under FreeDOS because

 * the DOS-C kernel does not implement the required flag.

 * returns 0 on success (ie. "disk exists and is writeable"). */

static unsigned short test_drive_write(char drive) {

  unsigned short result = 0;

  char *buff = "@:\\SVWRTEST.123";

  buff[0] = drive;

  _asm {

    push ax

    push bx

    push cx

    push dx

    mov ah, 0x6c   /* extended open/create file */

    mov bx, 0x2001 /* open for write + inhibit int 24h handler */

    xor cx, cx     /* file attributes on the created file */

    mov dx, 0x0010 /* create file if does not exist, fail if it exists */

    mov si, buff   /* filename to create */

    int 0x21

    jc FAILURE

    /* close the file (handle in AX) */

    mov bx, ax

    mov ah, 0x3e /* close file */

    int 0x21

    jc FAILURE

    /* delete the file */

    mov ah, 0x41 /* delete file pointed out by DS:DX */

    mov dx, buff

    int 0x21

    jnc DONE

    FAILURE:

    mov result, ax

    DONE:

    pop dx

    pop cx

    pop bx

    pop ax

  }

  return(result);

}

/* read MBR of driveid (0x80, 0x81..) into buff */

static int READMBR(char *buff, unsigned char driveid);

#pragma aux READMBR = \

"push es" \

"mov ax, 0x0201"  /* read 1 sector into memory */ \

"mov cx, 0x0001"  /* cylinder 0, sector 1 */ \

"xor dh, dh"      /* head 0 */ \

"push ds" \

"pop es" \

"int 0x13" \

"mov ax, 0" /* do not do "xor ax, ax", CF needs to be preserved */ \

"jnc DONE" \

"inc ax" \

"DONE:" \

"pop es" \

parm [bx] [dl] \

modify [cx dx] \

value [ax]

/*

 * MBR structure:

 *

 * Boot signature (word 0xAA55) is at 0x01FE

 *

 * partition entry 1 is at 0x01BE

 *                 2    at 0x01CE

 *                 3    at 0x01DE

 *                 4    at 0x01EE

 *

 * a partition entry is:

 * 0x00  status byte (active is bit 0x80 set)

 * 0x01  CHS addr of first sector (here: HEAD)

 * 0x02  CHS addr of first sector (CCSSSSSS) sector in 6 low bits, cylinder high bits in CC

 * 0x03  CHS addr of furst sector (here: low 8 bits of cylinder)

 * 0x04  Partition type:

        0x06/0x08 for CHS FAT16/32

        0x0E/0x0C for LBA FAT16/32

 * 0x05  CHS addr of last sector (same format as for 1st sector)

 * 0x06  CHS addr of last sector (same format as for 1st sector)

 * 0x07  CHS addr of last sector (same format as for 1st sector)

 * 0x08  LBA addr of first sector (4 bytes) - used sometimes instead of CHS

 * 0x0C  number of sectors in partition (4 bytes)

 */

struct drivelist {

  unsigned long start_lba;

  unsigned long tot_sect;  /* size (of partition), in sectors */

  unsigned short tot_size; /* size in MiB */

  unsigned char active;

  unsigned char partid;    /* position of the partition in the MBR (0,1,2,3) */

  unsigned char hd;        /* 0x80, 0x81... */

  unsigned char dosid;     /* DOS drive id (A=1, B=2...)*/

};

/* a (very partial) struct mimicking what EDR-DOS uses in int 2Fh,AX=0803h */

#pragma pack (push)

#pragma pack (0) /* disable the automatic alignment of struct members */

struct dos_udsc {

  unsigned short next_off;   /* offset FFFFh if last */

  unsigned short next_seg;

  unsigned char hd;     /* physical unit, as used by int 13h */

  unsigned char letter; /* DOS letter drive (A=0, B=1, C=2, ...) */

  unsigned short sectsize; /* bytes per sector */

  unsigned char unknown[15];

  unsigned long start_lba; /* LBA address of the partition (only for primary partitions) */

};

#pragma pack (pop)

/* get the DOS drive data table list */

static struct dos_udsc far *get_dos_udsc(void)  {

  unsigned short udsc_seg = 0, udsc_off = 0;

  _asm {

    push ds

    push di

    mov ax, 0x0803

    int 0x2f

    /* drive data table list is in DS:DI now */

    mov udsc_seg, ds

    mov udsc_off, di

    pop di

    pop ds

  }

  if (udsc_off == 0xffff) return(NULL);

  return(MK_FP(udsc_seg, udsc_off));

}

/* reads the MBR and matches its entries to DOS drives

 * fills the drives array with up to 16 drives (4 partitions * 4 disks)

 * see https://github.com/SvarDOS/bugz/issues/89 */

static int get_drives_list(char *buff, struct drivelist *drives) {

  int i;

  int listlen = 0;

  int drv;

  struct dos_udsc far *udsc_root = get_dos_udsc();

  struct dos_udsc far *udsc_node;

  for (drv = 0x80; drv < 0x84; drv++) {

    if (READMBR(buff, drv) != 0) continue;

    /* check boot signature at 0x01fe */

    if (*(unsigned short *)(buff + 0x01fe) != 0xAA55) continue;

    /* iterate over the 4 partitions in the MBR */

    for (i = 0; i < 4; i++) {

      unsigned char *entry;

      entry = buff + 0x01BE + (i * 16);

      /* ignore partition if fs is unknown (non-FAT) */

      if ((entry[4] != 0x0E) && (entry[4] != 0x0C)  /* LBA FAT */

       && (entry[4] != 0x01) && (entry[4] != 0x06) && (entry[4] != 0x08)) { /* CHS FAT */

        continue;

      }

      bzero(&(drives[listlen]), sizeof(struct drivelist));

      drives[listlen].hd = drv;

      drives[listlen].partid = i;

      drives[listlen].active = entry[0] >> 7;

      drives[listlen].start_lba = ((unsigned long *)entry)[2];

      drives[listlen].tot_sect = ((unsigned long *)entry)[3];

      /* now iterate over DOS drives and try to match ont to this MBR entry */

      udsc_node = udsc_root;

      while (udsc_node != NULL) {

        if (udsc_node->hd != drv) goto NEXT;

        if (udsc_node->start_lba != drives[listlen].start_lba) goto NEXT;

        /* FOUND! */

        drives[listlen].dosid = udsc_node->letter + 1;

        {

          unsigned long sz = (drives[listlen].tot_sect * udsc_node->sectsize) >> 20;

          drives[listlen].tot_size = (unsigned short)sz;

        }

        listlen++;

        break;

        NEXT:

        if (udsc_node->next_off == 0xffff) break;

        udsc_node = MK_FP(udsc_node->next_seg, udsc_node->next_off);

      } /* iterate over UDSC nodes */

    } /* iterate over partition entries of the MBR */

  } /* iterate over BIOS disks (0x80, 0x81, ...) */

  return(listlen);

}

/* displays a list of drives and asks user to choose one for installation

 * returns a word with DOS drive value in lowest 8 bits (A=1, B=2, etc) and

 * the BIOS drive id in highest 8 bits (1, 2...) */

static int selectdrive(void) {

  char buff[512];

  struct drivelist drives[16];

  char drvlist[16][32]; /* up to 16 drives (4 partitions on 4 disks) */

  int i, drvlistlen;

  const char *menulist[16];

  unsigned char driveid = 1; /* fdisk runs on first drive (unless USB boot) */

  /* read MBR of first HDD */

  drvlistlen = get_drives_list(buff, drives);

  /* if no drive found - disk not partitioned? */