Lines Matching defs:wbpb
107 static void swap_pack_grabsebpb(bpb_t *wbpb, struct _boot_sector *bsp);
108 static void swap_pack_bpb32cpy(struct _boot_sector32 *bsp, bpb_t *wbpb);
109 static void swap_pack_sebpbcpy(struct _boot_sector *bsp, bpb_t *wbpb);
110 static void swap_pack_grabbpb(bpb_t *wbpb, struct _boot_sector *bsp);
111 static void swap_pack_bpbcpy(struct _boot_sector *bsp, bpb_t *wbpb);
114 static uchar_t *build_rootdir(bpb_t *wbpb, char *ffn, int fffd,
116 static uchar_t *build_fat(bpb_t *wbpb, struct fat_od_fsi *fsinfop,
123 bpb_t *wbpb, int *prtsize, int *prtspc, int *prtbpf, int *prtnsect,
127 bpb_t *wbpb);
128 static void compute_file_area_size(bpb_t *wbpb);
132 static void compute_cluster_size(bpb_t *wbpb);
133 static void find_fixed_details(int fd, bpb_t *wbpb);
135 static void floppy_bpb_fillin(bpb_t *wbpb,
137 static void read_existing_bpb(int fd, bpb_t *wbpb);
143 static void write_bootsects(int fd, boot_sector_t *bsp, bpb_t *wbpb,
145 static void fill_bpb_sizes(bpb_t *wbpb, struct ipart part[],
147 static void set_fat_string(bpb_t *wbpb, int fatsize);
151 static void lookup_floppy(struct fd_char *fdchar, bpb_t *wbpb);
152 static void label_volume(char *lbl, bpb_t *wbpb);
158 static void write_rest(bpb_t *wbpb, char *efn,
161 char *ffn, bpb_t *wbpb);
165 static int prepare_image_file(char *fn, bpb_t *wbpb);
168 static int open_and_examine(char *dn, bpb_t *wbpb);
171 static int open_and_seek(char *dn, bpb_t *wbpb, off64_t *seekto);
176 static int seek_nofdisk(int fd, bpb_t *wbpb, off64_t *seekto);
178 static int seek_partn(int fd, char *pn, bpb_t *wbpb, off64_t *seekto);
487 fill_fat32_bpb(bpb_t *wbpb)
511 wbpb->bpb32.ext_flags = 0x0;
517 wbpb->bpb32.fs_vers_lo = '\0';
518 wbpb->bpb32.fs_vers_hi = '\0';
525 wbpb->bpb32.fsinfosec = 1;
526 wbpb->bpb32.backupboot = 6;
531 fill_bpb_sizes(bpb_t *wbpb, struct ipart part[], int partno, off64_t offset)
553 wbpb->bpb.sectors_in_volume = 0;
555 wbpb->bpb.sectors_in_volume = usesize;
556 wbpb->bpb.sectors_in_logical_volume = usesize;
559 wbpb->bpb.hidden_sectors = offset;
564 wbpb->sunbpb.bs_offset_high = offset >> 16;
565 wbpb->sunbpb.bs_offset_low = offset & 0xFFFF;
614 seek_partn(int fd, char *pn, bpb_t *wbpb, off64_t *seekto)
718 fill_bpb_sizes(wbpb, part, bootPart, *seekto);
740 fill_bpb_sizes(wbpb, part, primaryPart, *seekto);
857 fill_bpb_sizes(wbpb, part, extndDrives[driveIndex],
898 fill_bpb_sizes(wbpb, part, extraDrives[driveIndex], *seekto);
926 seek_nofdisk(int fd, bpb_t *wbpb, off64_t *seekto)
929 wbpb->bpb.sectors_in_volume = 0;
931 wbpb->bpb.sectors_in_volume = (short)TotSize;
932 wbpb->bpb.sectors_in_logical_volume = TotSize;
935 wbpb->bpb.hidden_sectors = RelOffset;
936 wbpb->sunbpb.bs_offset_high = RelOffset >> 16;
937 wbpb->sunbpb.bs_offset_low = RelOffset & 0xFFFF;
959 set_fat_string(bpb_t *wbpb, int fatsize)
962 (void) strncpy((char *)wbpb->ebpb.type, FAT12_TYPE_STRING,
965 (void) strncpy((char *)wbpb->ebpb.type, FAT16_TYPE_STRING,
968 (void) strncpy((char *)wbpb->ebpb.type, FAT32_TYPE_STRING,
981 prepare_image_file(char *fn, bpb_t *wbpb)
993 wbpb->bpb.sectors_in_volume = 2 * 80 * 15;
994 wbpb->bpb.sectors_in_logical_volume = 2 * 80 * 15;
995 wbpb->bpb.sectors_per_track = 15;
996 wbpb->bpb.heads = 2;
997 wbpb->bpb.media = 0xF9;
998 wbpb->bpb.num_root_entries = 224;
999 wbpb->bpb.sectors_per_cluster = 1;
1000 wbpb->bpb.sectors_per_fat = 7;
1003 wbpb->bpb.sectors_in_volume = 2 * 80 * 18;
1004 wbpb->bpb.sectors_in_logical_volume = 2 * 80 * 18;
1005 wbpb->bpb.sectors_per_track = 18;
1006 wbpb->bpb.heads = 2;
1007 wbpb->bpb.media = 0xF0;
1008 wbpb->bpb.num_root_entries = 224;
1009 wbpb->bpb.sectors_per_cluster = 1;
1010 wbpb->bpb.sectors_per_fat = 9;
1017 if (lseek(fd, (wbpb->bpb.sectors_in_volume * BPSEC)-1, SEEK_SET) < 0) {
1036 set_fat_string(wbpb, Fatentsize);
1038 wbpb->ebpb.phys_drive_num = 0;
1040 wbpb->sunbpb.bs_offset_high = 0;
1041 wbpb->sunbpb.bs_offset_low = 0;
1094 floppy_bpb_fillin(bpb_t *wbpb, int diam, int hds, int spt)
1102 wbpb->bpb.media = 0xF9;
1103 wbpb->bpb.num_root_entries = 112;
1104 wbpb->bpb.sectors_per_cluster = 2;
1105 wbpb->bpb.sectors_per_fat = 3;
1108 wbpb->bpb.media = 0xF0;
1109 wbpb->bpb.num_root_entries = 224;
1110 wbpb->bpb.sectors_per_cluster = 1;
1111 wbpb->bpb.sectors_per_fat = 9;
1114 wbpb->bpb.media = 0xF0;
1115 wbpb->bpb.num_root_entries = 240;
1116 wbpb->bpb.sectors_per_cluster = 2;
1117 wbpb->bpb.sectors_per_fat = 9;
1140 wbpb->bpb.media = 0xF9;
1141 wbpb->bpb.num_root_entries = 224;
1142 wbpb->bpb.sectors_per_cluster = 1;
1143 wbpb->bpb.sectors_per_fat = 7;
1146 wbpb->bpb.media = 0xFD;
1147 wbpb->bpb.num_root_entries = 112;
1148 wbpb->bpb.sectors_per_cluster = 2;
1149 wbpb->bpb.sectors_per_fat = 2;
1152 wbpb->bpb.media = 0xFF;
1153 wbpb->bpb.num_root_entries = 112;
1154 wbpb->bpb.sectors_per_cluster = 1;
1155 wbpb->bpb.sectors_per_fat = 2;
1168 wbpb->bpb.media = 0xFC;
1169 wbpb->bpb.num_root_entries = 64;
1170 wbpb->bpb.sectors_per_cluster = 1;
1171 wbpb->bpb.sectors_per_fat = 2;
1174 wbpb->bpb.media = 0xFE;
1175 wbpb->bpb.num_root_entries = 64;
1176 wbpb->bpb.sectors_per_cluster = 1;
1177 wbpb->bpb.sectors_per_fat = 1;
1210 lookup_floppy(struct fd_char *fdchar, bpb_t *wbpb)
1226 wbpb->bpb.sectors_in_logical_volume = tsize;
1228 wbpb->bpb.sectors_in_logical_volume =
1233 wbpb->bpb.sectors_in_volume =
1234 (short)wbpb->bpb.sectors_in_logical_volume;
1237 wbpb->bpb.sectors_per_track = spt;
1239 wbpb->bpb.sectors_per_track =
1243 spt = wbpb->bpb.sectors_per_track;
1247 wbpb->bpb.heads = hds;
1249 wbpb->bpb.heads =
1253 hds = wbpb->bpb.heads;
1260 set_fat_string(wbpb, Fatentsize);
1262 wbpb->ebpb.phys_drive_num = 0;
1264 wbpb->bpb.hidden_sectors = 0;
1265 wbpb->sunbpb.bs_offset_high = 0;
1266 wbpb->sunbpb.bs_offset_low = 0;
1268 floppy_bpb_fillin(wbpb, diam, hds, spt);
1287 compute_cluster_size(bpb_t *wbpb)
1301 volsize = wbpb->bpb.sectors_in_volume ? wbpb->bpb.sectors_in_volume :
1302 wbpb->bpb.sectors_in_logical_volume;
1303 volsize -= wbpb->bpb.resv_sectors;
1385 rds = ((wbpb->bpb.num_root_entries * 32) +
1386 (wbpb->bpb.bytes_sector - 1)) / wbpb->bpb.bytes_sector;
1423 wbpb->bpb.sectors_per_cluster = spc;
1443 set_fat_string(wbpb, Fatentsize);
1462 tmpval1 = volsize - (wbpb->bpb.resv_sectors + rds);
1464 tmpval2 = (256 * wbpb->bpb.sectors_per_cluster) + wbpb->bpb.num_fats;
1474 wbpb->bpb.sectors_per_fat = 0;
1475 wbpb->bpb32.big_sectors_per_fat = fatsz;
1478 "FAT32 = %d\n", wbpb->bpb32.big_sectors_per_fat);
1482 wbpb->bpb.sectors_per_fat = (ushort_t)(fatsz & 0x0000FFFF);
1485 "FAT16 = %d\n", wbpb->bpb.sectors_per_fat);
1492 find_fixed_details(int fd, bpb_t *wbpb)
1512 wbpb->bpb.heads = (GetTPC ? dginfo.dkg_nhead : TrkPerCyl);
1513 wbpb->bpb.sectors_per_track = (GetSPT ? dginfo.dkg_nsect : SecPerTrk);
1533 wbpb->bpb.media = 0xF8;
1535 wbpb->bpb.num_root_entries = 0;
1537 wbpb->bpb.num_root_entries = 512;
1538 wbpb->ebpb.phys_drive_num = 0x80;
1539 compute_cluster_size(wbpb);
1571 compute_file_area_size(bpb_t *wbpb)
1577 ((wbpb->bpb.num_root_entries * 32) + (wbpb->bpb.bytes_sector - 1)) /
1578 wbpb->bpb.bytes_sector;
1580 if (wbpb->bpb.sectors_per_fat) {
1584 FATSz = wbpb->bpb.sectors_per_fat;
1585 TotSec = wbpb->bpb.sectors_in_volume;
1590 FATSz = wbpb->bpb32.big_sectors_per_fat;
1591 TotSec = wbpb->bpb.sectors_in_logical_volume;
1595 (wbpb->bpb.resv_sectors + (wbpb->bpb.num_fats * FATSz) +
1602 TotalClusters = DataSec / wbpb->bpb.sectors_per_cluster;
1607 "bytes.\n"), TotalClusters, wbpb->bpb.sectors_per_cluster,
1608 TotalClusters * wbpb->bpb.sectors_per_cluster * BPSEC);
1625 swap_pack_bpbcpy(struct _boot_sector *bsp, bpb_t *wbpb)
1631 store_16_bits(&fillp, wbpb->bpb.bytes_sector);
1632 *fillp++ = wbpb->bpb.sectors_per_cluster;
1633 store_16_bits(&fillp, wbpb->bpb.resv_sectors);
1634 *fillp++ = wbpb->bpb.num_fats;
1635 store_16_bits(&fillp, wbpb->bpb.num_root_entries);
1636 store_16_bits(&fillp, wbpb->bpb.sectors_in_volume);
1637 *fillp++ = wbpb->bpb.media;
1638 store_16_bits(&fillp, wbpb->bpb.sectors_per_fat);
1639 store_16_bits(&fillp, wbpb->bpb.sectors_per_track);
1640 store_16_bits(&fillp, wbpb->bpb.heads);
1641 store_32_bits(&fillp, wbpb->bpb.hidden_sectors);
1642 store_32_bits(&fillp, wbpb->bpb.sectors_in_logical_volume);
1644 *fillp++ = wbpb->ebpb.phys_drive_num;
1645 *fillp++ = wbpb->ebpb.reserved;
1646 *fillp++ = wbpb->ebpb.ext_signature;
1647 store_32_bits(&fillp, wbpb->ebpb.volume_id);
1648 (void) strncpy((char *)fillp, (char *)wbpb->ebpb.volume_label, 11);
1650 (void) strncpy((char *)fillp, (char *)wbpb->ebpb.type, 8);
1655 swap_pack_bpb32cpy(struct _boot_sector32 *bsp, bpb_t *wbpb)
1662 store_16_bits(&fillp, wbpb->bpb.bytes_sector);
1663 *fillp++ = wbpb->bpb.sectors_per_cluster;
1664 store_16_bits(&fillp, wbpb->bpb.resv_sectors);
1665 *fillp++ = wbpb->bpb.num_fats;
1666 store_16_bits(&fillp, wbpb->bpb.num_root_entries);
1667 store_16_bits(&fillp, wbpb->bpb.sectors_in_volume);
1668 *fillp++ = wbpb->bpb.media;
1669 store_16_bits(&fillp, wbpb->bpb.sectors_per_fat);
1670 store_16_bits(&fillp, wbpb->bpb.sectors_per_track);
1671 store_16_bits(&fillp, wbpb->bpb.heads);
1672 store_32_bits(&fillp, wbpb->bpb.hidden_sectors);
1673 store_32_bits(&fillp, wbpb->bpb.sectors_in_logical_volume);
1675 store_32_bits(&fillp, wbpb->bpb32.big_sectors_per_fat);
1676 store_16_bits(&fillp, wbpb->bpb32.ext_flags);
1677 *fillp++ = wbpb->bpb32.fs_vers_lo;
1678 *fillp++ = wbpb->bpb32.fs_vers_hi;
1679 store_32_bits(&fillp, wbpb->bpb32.root_dir_clust);
1680 store_16_bits(&fillp, wbpb->bpb32.fsinfosec);
1681 store_16_bits(&fillp, wbpb->bpb32.backupboot);
1683 store_16_bits(&fillp, wbpb->bpb32.reserved[r]);
1685 *fillp++ = wbpb->ebpb.phys_drive_num;
1686 *fillp++ = wbpb->ebpb.reserved;
1687 *fillp++ = wbpb->ebpb.ext_signature;
1688 store_32_bits(&fillp, wbpb->ebpb.volume_id);
1689 (void) strncpy((char *)fillp, (char *)wbpb->ebpb.volume_label, 11);
1691 (void) strncpy((char *)fillp, (char *)wbpb->ebpb.type, 8);
1696 swap_pack_sebpbcpy(struct _boot_sector *bsp, bpb_t *wbpb)
1701 store_16_bits(&fillp, wbpb->sunbpb.bs_offset_high);
1702 store_16_bits(&fillp, wbpb->sunbpb.bs_offset_low);
1707 swap_pack_grabbpb(bpb_t *wbpb, struct _boot_sector *bsp)
1713 ((uchar_t *)&(wbpb->bpb.bytes_sector))[1] = *grabp++;
1714 ((uchar_t *)&(wbpb->bpb.bytes_sector))[0] = *grabp++;
1715 wbpb->bpb.sectors_per_cluster = *grabp++;
1716 ((uchar_t *)&(wbpb->bpb.resv_sectors))[1] = *grabp++;
1717 ((uchar_t *)&(wbpb->bpb.resv_sectors))[0] = *grabp++;
1718 wbpb->bpb.num_fats = *grabp++;
1719 ((uchar_t *)&(wbpb->bpb.num_root_entries))[1] = *grabp++;
1720 ((uchar_t *)&(wbpb->bpb.num_root_entries))[0] = *grabp++;
1721 ((uchar_t *)&(wbpb->bpb.sectors_in_volume))[1] = *grabp++;
1722 ((uchar_t *)&(wbpb->bpb.sectors_in_volume))[0] = *grabp++;
1723 wbpb->bpb.media = *grabp++;
1724 ((uchar_t *)&(wbpb->bpb.sectors_per_fat))[1] = *grabp++;
1725 ((uchar_t *)&(wbpb->bpb.sectors_per_fat))[0] = *grabp++;
1726 ((uchar_t *)&(wbpb->bpb.sectors_per_track))[1] = *grabp++;
1727 ((uchar_t *)&(wbpb->bpb.sectors_per_track))[0] = *grabp++;
1728 ((uchar_t *)&(wbpb->bpb.heads))[1] = *grabp++;
1729 ((uchar_t *)&(wbpb->bpb.heads))[0] = *grabp++;
1730 ((uchar_t *)&(wbpb->bpb.hidden_sectors))[3] = *grabp++;
1731 ((uchar_t *)&(wbpb->bpb.hidden_sectors))[2] = *grabp++;
1732 ((uchar_t *)&(wbpb->bpb.hidden_sectors))[1] = *grabp++;
1733 ((uchar_t *)&(wbpb->bpb.hidden_sectors))[0] = *grabp++;
1734 ((uchar_t *)&(wbpb->bpb.sectors_in_logical_volume))[3] = *grabp++;
1735 ((uchar_t *)&(wbpb->bpb.sectors_in_logical_volume))[2] = *grabp++;
1736 ((uchar_t *)&(wbpb->bpb.sectors_in_logical_volume))[1] = *grabp++;
1737 ((uchar_t *)&(wbpb->bpb.sectors_in_logical_volume))[0] = *grabp++;
1738 wbpb->ebpb.phys_drive_num = *grabp++;
1739 wbpb->ebpb.reserved = *grabp++;
1740 wbpb->ebpb.ext_signature = *grabp++;
1741 ((uchar_t *)&(wbpb->ebpb.volume_id))[3] = *grabp++;
1742 ((uchar_t *)&(wbpb->ebpb.volume_id))[2] = *grabp++;
1743 ((uchar_t *)&(wbpb->ebpb.volume_id))[1] = *grabp++;
1744 ((uchar_t *)&(wbpb->ebpb.volume_id))[0] = *grabp++;
1746 (void) strncpy((char *)wbpb->ebpb.volume_label, (char *)grabp, 11);
1748 (void) strncpy((char *)wbpb->ebpb.type, (char *)grabp, 8);
1753 swap_pack_grabsebpb(bpb_t *wbpb, struct _boot_sector *bsp)
1758 ((uchar_t *)&(wbpb->sunbpb.bs_offset_high))[1] = *grabp++;
1759 ((uchar_t *)&(wbpb->sunbpb.bs_offset_high))[0] = *grabp++;
1760 ((uchar_t *)&(wbpb->sunbpb.bs_offset_low))[1] = *grabp++;
1761 ((uchar_t *)&(wbpb->sunbpb.bs_offset_low))[0] = *grabp++;
1766 swap_pack_grab32bpb(bpb_t *wbpb, struct _boot_sector *bsp)
1772 ((uchar_t *)&(wbpb->bpb32.big_sectors_per_fat))[3] = *grabp++;
1773 ((uchar_t *)&(wbpb->bpb32.big_sectors_per_fat))[2] = *grabp++;
1774 ((uchar_t *)&(wbpb->bpb32.big_sectors_per_fat))[1] = *grabp++;
1775 ((uchar_t *)&(wbpb->bpb32.big_sectors_per_fat))[0] = *grabp++;
1776 ((uchar_t *)&(wbpb->bpb32.ext_flags))[1] = *grabp++;
1777 ((uchar_t *)&(wbpb->bpb32.ext_flags))[0] = *grabp++;
1778 wbpb->bpb32.fs_vers_lo = *grabp++;
1779 wbpb->bpb32.fs_vers_hi = *grabp++;
1780 ((uchar_t *)&(wbpb->bpb32.root_dir_clust))[3] = *grabp++;
1781 ((uchar_t *)&(wbpb->bpb32.root_dir_clust))[2] = *grabp++;
1782 ((uchar_t *)&(wbpb->bpb32.root_dir_clust))[1] = *grabp++;
1783 ((uchar_t *)&(wbpb->bpb32.root_dir_clust))[0] = *grabp++;
1784 ((uchar_t *)&(wbpb->bpb32.fsinfosec))[1] = *grabp++;
1785 ((uchar_t *)&(wbpb->bpb32.fsinfosec))[0] = *grabp++;
1786 ((uchar_t *)&(wbpb->bpb32.backupboot))[1] = *grabp++;
1787 ((uchar_t *)&(wbpb->bpb32.backupboot))[0] = *grabp++;
1788 ((uchar_t *)&(wbpb->bpb32.reserved[0]))[1] = *grabp++;
1789 ((uchar_t *)&(wbpb->bpb32.reserved[0]))[0] = *grabp++;
1790 ((uchar_t *)&(wbpb->bpb32.reserved[1]))[1] = *grabp++;
1791 ((uchar_t *)&(wbpb->bpb32.reserved[1]))[0] = *grabp++;
1792 ((uchar_t *)&(wbpb->bpb32.reserved[2]))[1] = *grabp++;
1793 ((uchar_t *)&(wbpb->bpb32.reserved[2]))[0] = *grabp++;
1794 ((uchar_t *)&(wbpb->bpb32.reserved[3]))[1] = *grabp++;
1795 ((uchar_t *)&(wbpb->bpb32.reserved[3]))[0] = *grabp++;
1796 ((uchar_t *)&(wbpb->bpb32.reserved[4]))[1] = *grabp++;
1797 ((uchar_t *)&(wbpb->bpb32.reserved[4]))[0] = *grabp++;
1798 ((uchar_t *)&(wbpb->bpb32.reserved[5]))[1] = *grabp++;
1799 ((uchar_t *)&(wbpb->bpb32.reserved[5]))[0] = *grabp++;
1823 read_existing_bpb(int fd, bpb_t *wbpb)
1839 (void) memcpy(&(wbpb->bpb), &(ubpb.bs.bs_front.bs_bpb),
1840 sizeof (wbpb->bpb));
1841 (void) memcpy(&(wbpb->ebpb), &(ubpb.bs.bs_ebpb), sizeof (wbpb->ebpb));
1843 swap_pack_grabbpb(wbpb, &(ubpb.bs));
1847 (void) memcpy(&(wbpb->sunbpb), &(ubpb.bs.bs_sebpb),
1848 sizeof (wbpb->sunbpb));
1850 swap_pack_grabsebpb(wbpb, &(ubpb.bs));
1853 if (wbpb->bpb.bytes_sector != BPSEC) {
1856 if (!(ISP2(wbpb->bpb.bytes_sector) &&
1857 IN_RANGE(wbpb->bpb.bytes_sector, 1, BPSEC * 8))) {
1869 wbpb->bpb.bytes_sector);
1874 if (!(ISP2(wbpb->bpb.sectors_per_cluster) &&
1875 IN_RANGE(wbpb->bpb.sectors_per_cluster, 1, 128))) {
1885 if (wbpb->bpb.sectors_per_fat == 0) {
1887 (void) memcpy(&(wbpb->bpb32), &(ubpb.bs32.bs_bpb32),
1888 sizeof (wbpb->bpb32));
1890 swap_pack_grab32bpb(wbpb, &(ubpb.bs));
1892 compute_file_area_size(wbpb);
1893 if ((wbpb->bpb32.big_sectors_per_fat * BPSEC / 4) >=
1900 compute_file_area_size(wbpb);
1922 bpb_t *wbpb, int *prtsize, int *prtspc, int *prtbpf, int *prtnsect,
1936 compare = *wbpb;
1951 if (compare.bpb.heads != wbpb->bpb.heads) {
1956 wbpb->bpb.sectors_per_track) {
1976 if (dginfo.dkg_nhead != wbpb->bpb.heads) {
1981 wbpb->bpb.sectors_per_track) {
1990 if (!*prtfdisk && TotSize != wbpb->bpb.sectors_in_volume &&
1991 TotSize != wbpb->bpb.sectors_in_logical_volume) {
1996 if (compare.bpb.sectors_per_cluster != wbpb->bpb.sectors_per_cluster) {
2001 if (compare.bpb.hidden_sectors != wbpb->bpb.hidden_sectors) {
2006 if (compare.bpb.resv_sectors != wbpb->bpb.resv_sectors) {
2021 fatents = wbpb->bpb.sectors_per_fat * BPSEC * 2 / 3;
2022 if (fatents >= TotalClusters && wbpb->ebpb.type[4] == '2')
2035 print_reproducing_command(int fd, char *actualdisk, char *suffix, bpb_t *wbpb)
2049 compare_existing_with_computed(fd, suffix, wbpb,
2059 ll = min(11, (int)strlen((char *)wbpb->ebpb.volume_label));
2066 while (wbpb->ebpb.volume_label[--i] == ' ')
2076 toupper((int)(wbpb->ebpb.volume_label[i]))) {
2088 (void) printf("%c", wbpb->ebpb.volume_label[i]);
2109 (void) printf("size=%u", wbpb->bpb.sectors_in_volume ?
2110 wbpb->bpb.sectors_in_volume :
2111 wbpb->bpb.sectors_in_logical_volume);
2116 (void) printf("nsect=%d", wbpb->bpb.sectors_per_track);
2121 (void) printf("spc=%d", wbpb->bpb.sectors_per_cluster);
2126 (void) printf("ntrack=%d", wbpb->bpb.heads);
2136 (void) printf("hidden=%u", wbpb->bpb.hidden_sectors);
2141 (void) printf("reserve=%d", wbpb->bpb.resv_sectors);
2163 open_and_examine(char *dn, bpb_t *wbpb)
2208 if (suffix && !(seek_partn(fd, suffix, wbpb, &ignored))) {
2213 read_existing_bpb(fd, wbpb);
2214 print_reproducing_command(fd, actualdisk, suffix, wbpb);
2231 open_and_seek(char *dn, bpb_t *wbpb, off64_t *seekto)
2248 wbpb->bpb.num_fats = 2;
2249 wbpb->bpb.bytes_sector = BPSEC;
2257 wbpb->bpb.resv_sectors = 32;
2259 wbpb->bpb.resv_sectors = 1;
2261 wbpb->bpb.resv_sectors = Resrvd;
2263 wbpb->ebpb.ext_signature = 0x29; /* Magic number for modern format */
2264 wbpb->ebpb.volume_id = 0;
2267 fill_fat32_bpb(wbpb);
2274 return (fd = prepare_image_file(dn, wbpb));
2322 if (suffix && !(seek_partn(fd, suffix, wbpb, seekto))) {
2341 if (!(seek_nofdisk(fd, wbpb, seekto))) {
2345 find_fixed_details(fd, wbpb);
2368 lookup_floppy(&fdchar, wbpb);
2379 lookup_floppy(&fdchar, wbpb);
2382 find_fixed_details(fd, wbpb);
2561 label_volume(char *lbl, bpb_t *wbpb)
2571 wbpb->ebpb.volume_label[i] = toupper(lbl[i]);
2574 wbpb->ebpb.volume_label[i] = ' ';
2645 build_fat(bpb_t *wbpb, struct fat_od_fsi *fsinfop, ulong_t bootblksize,
2657 wbpb->bpb.sectors_per_fat ? wbpb->bpb.sectors_per_fat :
2658 wbpb->bpb32.big_sectors_per_fat);
2662 *fatsize = BPSEC * wbpb->bpb32.big_sectors_per_fat;
2664 *fatsize = BPSEC * wbpb->bpb.sectors_per_fat;
2675 *fatp = wbpb->bpb.media;
2709 numclust = idivceil(numsect, wbpb->bpb.sectors_per_cluster);
2724 wbpb->bpb32.root_dir_clust = nextfree++;
2734 numclust = idivceil(numsect, wbpb->bpb.sectors_per_cluster);
2862 build_rootdir(bpb_t *wbpb, char *ffn, int fffd,
2877 *rdirsize = wbpb->bpb.sectors_per_cluster * BPSEC;
2879 *rdirsize = wbpb->bpb.num_root_entries * sizeof (struct pcdir);
2934 write_rest(bpb_t *wbpb, char *efn, int dfd, int sfd, int remaining)
2946 numclust = idivceil(numsect, wbpb->bpb.sectors_per_cluster);
2948 wnumsect = numclust * wbpb->bpb.sectors_per_cluster;
3020 write_bootsects(int fd, boot_sector_t *bsp, bpb_t *wbpb,
3026 (void) memcpy(&(bsp->bs32.bs_front.bs_bpb), &(wbpb->bpb),
3027 sizeof (wbpb->bpb));
3028 (void) memcpy(&(bsp->bs32.bs_bpb32), &(wbpb->bpb32),
3029 sizeof (wbpb->bpb32));
3030 (void) memcpy(&(bsp->bs32.bs_ebpb), &(wbpb->ebpb),
3031 sizeof (wbpb->ebpb));
3033 swap_pack_bpb32cpy(&(bsp->bs32), wbpb);
3038 (void) memcpy(&(bsp->bs.bs_front.bs_bpb), &(wbpb->bpb),
3039 sizeof (wbpb->bpb));
3040 (void) memcpy(&(bsp->bs.bs_ebpb), &(wbpb->ebpb),
3041 sizeof (wbpb->ebpb));
3043 swap_pack_bpbcpy(&(bsp->bs), wbpb);
3049 (void) memcpy(&(bsp->bs.bs_sebpb), &(wbpb->sunbpb),
3050 sizeof (wbpb->sunbpb));
3052 swap_pack_sebpbcpy(&(bsp->bs), wbpb);
3075 write_fat(int fd, off64_t seekto, char *fn, char *lbl, char *ffn, bpb_t *wbpb)
3085 compute_file_area_size(wbpb);
3088 label_volume(lbl, wbpb);
3092 fatp = build_fat(wbpb, &fsinfo, bootblksize, &fatsize,
3095 write_bootsects(fd, &bootsect, wbpb, &fsinfo, seekto);
3098 seekto + (BPSEC * wbpb->bpb.resv_sectors), SEEK_SET) < 0) {
3107 fatsize, wbpb->bpb.num_fats);
3110 for (nf = 0; nf < (int)wbpb->bpb.num_fats; nf++)
3124 rdirp = build_rootdir(wbpb, ffn, fffd, ffsize, ffsc, &rdirsize);
3150 write_rest(wbpb, fn, fd, bsfd, bootblksize - BPSEC);
3170 write_rest(wbpb, ffn, fd, fffd, ffsize);