| /* |
| * rescuept - Andries Brouwer - aeb@cwi.nl - 1999 |
| * |
| * This may be distributed under the GPL. |
| * |
| * call: rescuept /dev/xxx |
| * |
| * The output is a proposed partition table, in the |
| * form of input to sfdisk. Typical use: |
| * |
| * ./rescuept /dev/xxx > xxx.pt |
| * now look at xxx.pt to see whether it resembles what |
| * you expected, and possibly edit the partition types; |
| * if you are satisfied, then |
| * sfdisk /dev/xxx < xxx.pt |
| * will restore your partition table. If you are cautious, use |
| * sfdisk /dev/xxx -O xxx.old < xxx.pt |
| * so that the original state can be retrieved using |
| * sfdisk /dev/xxx -I xxx.old |
| * |
| * Here xxx stands for hda or hdb or sda or sdb or ... |
| */ |
| #include <stdio.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <unistd.h> |
| #include <sys/stat.h> |
| #include <sys/ioctl.h> |
| |
| #ifndef BLKGETSIZE |
| #define BLKGETSIZE _IO(0x12,96) |
| #endif |
| |
| char *progname; |
| char *device; |
| |
| #define MAXPARTITIONS 100 |
| |
| #define MAXPAGESZ 65536 |
| |
| #define BUFSZ 1024000 |
| #define BUFSECS (BUFSZ/512) |
| char buf[BUFSZ]; |
| int bufstart = -1; |
| |
| typedef unsigned int uint32; |
| typedef int sint32; |
| typedef unsigned short uint16; |
| typedef short sint16; |
| typedef unsigned char uchar; |
| |
| void read_sectors(int fd, char *buf, int sectornr, int sectorct) { |
| extern long long llseek(); |
| long long offset; |
| int n; |
| |
| offset = sectornr; |
| offset *= 512; |
| if (llseek(fd, offset, SEEK_SET) != offset) { |
| fprintf(stderr, "%s: llseek error\n", progname); |
| exit(1); |
| } |
| n = read(fd, buf, sectorct*512); |
| if (n != sectorct*512) { |
| if (n == -1) |
| perror("read"); |
| fprintf(stderr, "%s: error reading sectors %d-%d\n", |
| progname, sectornr, sectornr+sectorct-1); |
| exit(1); |
| } |
| } |
| |
| |
| /* |
| * Partition table stuff |
| */ |
| |
| struct partition { |
| unsigned char bootable; /* 0 or 0x80 */ |
| uchar begin_chs[3]; |
| unsigned char sys_type; |
| uchar end_chs[3]; |
| unsigned int start_sect; /* starting sector counting from 0 */ |
| unsigned int nr_sects; /* nr of sectors in partition */ |
| }; |
| |
| int |
| is_extended(unsigned char sys_type) { |
| return (sys_type == 0x5 || sys_type == 0xf || sys_type == 0x85); |
| } |
| |
| /* |
| * List of (extended) partition table sectors found |
| */ |
| struct epts { |
| int secno; |
| char pt4[64]; |
| } epts[MAXPARTITIONS]; |
| int eptsct; |
| |
| void addepts(int secno, char *data) { |
| if (eptsct >= MAXPARTITIONS) |
| return; /* ignore */ |
| epts[eptsct].secno = secno; |
| memcpy(epts[eptsct].pt4, data+512-66, 64); |
| eptsct++; |
| } |
| |
| /* |
| * List of guessed partitions |
| */ |
| struct pt { |
| int pno; |
| int start; |
| int size; |
| unsigned char type; |
| } pts[MAXPARTITIONS]; |
| int partno; |
| |
| void addpart(int start, int size, unsigned char type) { |
| if (partno >= MAXPARTITIONS) |
| return; /* ignore */ |
| pts[partno].start = start; |
| pts[partno].size = size; |
| pts[partno].type = type; |
| partno++; |
| } |
| |
| void outparts() { |
| int i; |
| |
| for(i=0; i<partno; i++) |
| printf("%s%d : start=%9d, size=%8d, Id=%2x\n", |
| device, pts[i].pno, |
| pts[i].start, pts[i].size, pts[i].type); |
| } |
| |
| void outmsg(char *msg, int start, int nextstart, unsigned char type) { |
| printf("# %5d MB %16s (type %2x): sectors %9d-%9d\n", |
| ((nextstart-start)+1024)/2048, msg, type, start, nextstart-1); |
| } |
| |
| int |
| create_extended_partition(int fd, int secno, int size) { |
| int sec = secno; |
| int cursec = secno; |
| int pno = partno; /* number of extd partition */ |
| int ei = eptsct-1; |
| unsigned char type = 0x5; |
| int lastseen = secno; |
| int ok = 0; |
| |
| if (epts[ei].secno != secno) { |
| fprintf(stderr, "%s: program bug\n", progname); |
| exit(1); |
| } |
| |
| outmsg("candidate ext pt", secno, secno+1, type); |
| addpart(secno, 1, type); /* size to be filled in later */ |
| |
| while(1) { |
| char buf[512]; |
| struct partition *p1, *p2, *pr, *pe; |
| p1 = (struct partition *)(& epts[ei].pt4[0]); |
| p2 = (struct partition *)(& epts[ei].pt4[16]); |
| /* for the time being we just ignore the rest */ |
| |
| if (is_extended(p1->sys_type)) { |
| pr = p2; |
| pe = p1; |
| } else if (is_extended(p2->sys_type)) { |
| pr = p1; |
| pe = p2; |
| } else if (p1->sys_type == 0) { |
| pr = p2; |
| pe = 0; |
| } else if (p2->sys_type == 0) { |
| pr = p1; |
| pe = 0; |
| } else |
| break; |
| |
| /* first handle the real partition, if any */ |
| if (pr->sys_type != 0) { |
| int ss = cursec + pr->start_sect; |
| int es = ss + pr->nr_sects; |
| outmsg("found in ept", ss, es, pr->sys_type); |
| addpart(ss, pr->nr_sects, pr->sys_type); |
| if (lastseen < es - 1) |
| lastseen = es - 1; |
| if (lastseen >= size) |
| break; |
| } |
| |
| |
| /* then the extended link */ |
| |
| if (!pe) { |
| ok = 1; |
| break; |
| } |
| type = pe->sys_type; |
| cursec = sec + pe->start_sect; |
| if (cursec >= size) |
| break; |
| read_sectors(fd, buf, cursec, 1); |
| addepts(cursec, buf); |
| ei = eptsct-1; |
| } |
| |
| if (!ok || lastseen == secno) { |
| printf("# retracted\n"); |
| partno = pno; |
| return 0; |
| } |
| |
| pts[pno].type = type; |
| pts[pno].size = lastseen+1-secno; |
| outmsg("extended part ok", secno, lastseen+1, type); |
| return lastseen; |
| } |
| |
| |
| |
| /* |
| * Recognize an ext2 superblock |
| */ |
| #define EXT2_SUPER_MAGIC 0xEF53 |
| |
| struct ext2_super_block { |
| uint32 s_inodes_count; /* 0: Inodes count */ |
| uint32 s_blocks_count; /* 4: Blocks count */ |
| uint32 s_r_blocks_count; /* 8: Reserved blocks count */ |
| uint32 s_free_blocks_count; /* 12: Free blocks count */ |
| uint32 s_free_inodes_count; /* 16: Free inodes count */ |
| uint32 s_first_data_block; /* 20: First Data Block */ |
| uint32 s_log_block_size; /* 24: Block size */ |
| sint32 s_log_frag_size; /* 28: Fragment size */ |
| uint32 s_blocks_per_group; /* 32: # Blocks per group */ |
| uint32 s_frags_per_group; /* 36: # Fragments per group */ |
| uint32 s_inodes_per_group; /* 40: # Inodes per group */ |
| uint32 s_mtime; /* 44: Mount time */ |
| uint32 s_wtime; /* 48: Write time */ |
| uint16 s_mnt_count; /* 52: Mount count */ |
| sint16 s_max_mnt_count; /* 54: Maximal mount count */ |
| uint16 s_magic; /* 56: Magic signature */ |
| uint16 s_state; /* 58: File system state */ |
| uint16 s_errors; /* 60: Behaviour when detecting errors */ |
| uint16 s_minor_rev_level; /* 62: minor revision level */ |
| uint32 s_lastcheck; /* 64: time of last check */ |
| uint32 s_checkinterval; /* 68: max. time between checks */ |
| uint32 s_creator_os; /* 72: OS */ |
| uint32 s_rev_level; /* 76: Revision level */ |
| uint16 s_def_resuid; /* 80: Default uid for reserved blocks */ |
| uint16 s_def_resgid; /* 82: Default gid for reserved blocks */ |
| |
| /* more stuff in later versions - especially s_block_group_nr is useful */ |
| uint32 s_first_ino; /* 84: First non-reserved inode */ |
| uint16 s_inode_size; /* 88: size of inode structure */ |
| uint16 s_block_group_nr; /* 90: block group # of this superblock */ |
| uint32 s_feature_compat; /* 92: compatible feature set */ |
| uint32 s_feature_incompat; /* 96: incompatible feature set */ |
| uint32 s_feature_ro_compat; /* 100: readonly-compatible feature set */ |
| uchar s_uuid[16]; /* 104: 128-bit uuid for volume */ |
| char s_volume_name[16]; /* 120: volume name */ |
| char s_last_mounted[64]; /* 136: directory where last mounted */ |
| uint32 s_algorithm_usage_bitmap;/* 200: For compression */ |
| uchar s_prealloc_blocks; /* 204: Nr of blocks to try to preallocate*/ |
| uchar s_prealloc_dir_blocks; /* 205: Nr to preallocate for dirs */ |
| uchar s_reserved[818]; /* 206-1023 */ |
| }; |
| |
| /* |
| * Heuristic to weed out false alarms for ext2 superblocks. |
| * Recompile this after 2005, of if you destroy things that |
| * have not been written the past ten years. |
| */ |
| #define YEAR (60*60*24*365) |
| #define LOWERLIMIT (1992-1970)*YEAR |
| #define UPPERLIMIT (2005-1970)*YEAR |
| int |
| is_time(uint32 t) { |
| return (t >= LOWERLIMIT && t <= UPPERLIMIT); |
| } |
| |
| int |
| is_ztime(uint32 t) { |
| return (t == 0 || (t >= LOWERLIMIT && t <= UPPERLIMIT)); |
| } |
| |
| /* |
| * Recognize a FAT filesystem |
| */ |
| |
| struct fat_boot_sector_start { |
| uchar jump_code[3]; /* 0: Bootstrap short or near jump */ |
| /* usually jump code (e.g. eb 3e or eb 58) + nop (0x90) */ |
| uchar system_id[8]; /* 3: OEM Name */ |
| /* fat16: MSDOS5.0 or MSWIN4.0 or ... */ |
| /* fat32: MSWIN4.1 (=W95 OSR2) */ |
| /* BIOS Parameter Block (BPB) */ |
| uchar sector_size[2]; /* 11: bytes/sector (usually 512 or 2048) */ |
| uchar cluster_size; /* 13: sectors/cluster (a power of two in 1..128) */ |
| uint16 reserved; /* 14: reserved sectors (I see 1 for FAT16, 17 for FAT32) */ |
| /* The # of sectors preceding the first FAT, |
| including the boot sector, so at least 1 */ |
| uchar fats; /* 16: # of copies of FAT (usually 2) */ |
| uchar dir_entries[2]; /* 17: max # of root directory entries (n/a for FAT32) */ |
| /* (usually 512; 0 for FAT32) */ |
| uchar sectors[2]; /* 19: total # of sectors (in <32MB partn) or 0 */ |
| uchar media; /* 21: media code (0xf8 for hard disks) */ |
| uint16 fat_length; /* 22: sectors/FAT (n/a: 0 for FAT32) */ |
| uint16 secs_track; /* 24: S = # sectors/track (in 1..63) */ |
| uint16 heads; /* 26: H = # of heads (in 1..255) */ |
| uint32 hidden; /* 28: # of hidden sectors in partition, before boot sector */ |
| /* (offset from cyl boundary - often equal to S) */ |
| uint32 total_sect; /* 32: # of sectors (if sectors == 0) */ |
| }; |
| |
| /* Media descriptor byte: |
| f8 hard disk |
| Floppy types: |
| f0 3.5" 36/2/80 2880k |
| f0 3.5" 18/2/80 1440k |
| f9 3.5" 9/2/80 720k |
| f9 5.25" 15/2/80 1200k |
| fa both 9/1/80 320k |
| fb both 9/2/80 640k |
| fc 5.25" 9/1/40 180k |
| fd 5.25" 9/2/40 360k |
| fe 5.25" 8/1/40 160k |
| ff 5.25" 8/2/40 320k |
| Conclusion: this byte does not differentiate between 3.5" and 5.25", |
| it does not give the capacity or the number of sectors per track. |
| However, maybe C and H can be derived. |
| */ |
| |
| struct fat_boot_sector_middle { /* offset 36-61 for FAT16, 64-89 for FAT32 */ |
| /* Extended BIOS Parameter Block */ |
| uchar drive_number; /* 0: logical drive number of partition */ |
| /* (typically 0 for floppy, 0x80 for each disk) */ |
| uchar current_head; /* Originally: track containing boot record. (Usually 0) |
| For WNT: bit 0: dirty: chkdsk must be run |
| bit 1: also run surface scan */ |
| uchar extd_signature; /* 2: extended signature (0x29) */ |
| /* WNT requires either 0x28 or 0x29 */ |
| uchar serial_nr[4]; /* 3: serial number of partition */ |
| uchar volume_name[11];/* 7: volume name of partition */ |
| /* WNT stores the volume label as a special file |
| in the root directory */ |
| uchar fs_name[8]; /* 18: filesystem name (FAT12, FAT16, FAT32) */ |
| }; |
| |
| struct fat16_boot_sector { |
| struct fat_boot_sector_start s; /* 0-35 */ |
| struct fat_boot_sector_middle m; /* 36-61 */ |
| uchar boot_code[448]; /* 62-509 */ |
| uchar signature[2]; /* 510-511: aa55 */ |
| }; |
| |
| struct fat32_boot_sector { |
| struct fat_boot_sector_start s; /* 0-35 */ |
| |
| uint32 fat32_length; /* 36: sectors/FAT */ |
| uint16 flags; /* 40: bit 7: fat mirroring, low 4: active fat */ |
| /* If mirroring is disabled (bit8 set) the FAT |
| info is only written to the active FAT copy. */ |
| uchar version[2]; /* 42: major, minor filesystem version */ |
| uint32 root_cluster; /* 44: first cluster in root directory */ |
| uint16 info_sector; /* 48: filesystem info sector # relative |
| to partition start (usually 1) */ |
| uint16 backup_boot; /* 50: backup boot sector # relat. to part. start */ |
| uint16 reserved2[6]; /* 52-63: Unused */ |
| |
| struct fat_boot_sector_middle m; /* 64-89 */ |
| uchar boot_code[420]; /* 90-509 */ |
| uchar signature[2]; /* 510-511: aa55 */ |
| }; |
| |
| /* |
| * The boot code contains message strings ("Invalid system disk") |
| * but these are often localized ("Ongeldige diskette "). |
| * After these messages one finds two or three filenames. |
| * (MSDOS 6.2: "\r\nNon-System disk or disk error\r\n" |
| * "Replace and press any key when ready\r\n", "IO SYS", "MSDOS SYS") |
| * (W95: "IO SYS", "MSDOS SYS", "WINBOOT SYS") |
| * In all cases the sector seems to end with 0, 0, 55, aa. |
| * |
| * Random collection of messages (closed by \0377 or 0): |
| * "\r\nInvalid system disk" |
| * "\r\nOngeldige diskette " |
| * "\r\nDisk I/O error" |
| * "\r\nI/O-fout " |
| * "\r\nReplace the disk, and then press any key\r\n" |
| * "\r\nVervang de diskette en druk op een toets\r\n" |
| * This seems to suggest that the localized strings have the same length. |
| * |
| * "Non-System disk or disk error" |
| * "Replace and press any key when ready" |
| * "Disk Boot failure" |
| * |
| * "BOOT: Couldn't find NTLDR" |
| * "I/O error reading disk" |
| * "Please insert another disk" |
| */ |
| |
| struct fat32_boot_fsinfo { |
| uint32 signature1; /* 41 61 52 52 */ |
| uchar unknown1[480]; |
| uint32 signature2; /* 61 41 72 72 0x61417272L */ |
| uint32 free_clusters; /* Free cluster count. -1 if unknown */ |
| uint32 next_cluster; /* Most recently allocated cluster. |
| * Unused under Linux. */ |
| uchar unknown2[14]; |
| uchar signature[2]; /* 510-511: aa55 */ |
| }; |
| |
| struct msdos_dir_entry { |
| uchar name[8],ext[3]; /* name and extension */ |
| uchar attr; /* attribute bits */ |
| uchar lcase; /* Case for base and extension */ |
| uchar ctime_ms; /* Creation time, milliseconds */ |
| uint16 ctime; /* Creation time */ |
| uint16 cdate; /* Creation date */ |
| uint16 adate; /* Last access date */ |
| uint16 starthi; /* High 16 bits of cluster in FAT32 */ |
| uint16 time,date,start;/* time, date and first cluster */ |
| uint32 size; /* file size (in bytes) */ |
| }; |
| |
| /* New swap space */ |
| struct swap_header_v1 { |
| char bootbits[1024]; /* Space for disklabel etc. */ |
| unsigned int version; |
| unsigned int last_page; |
| unsigned int nr_badpages; |
| unsigned int padding[125]; |
| unsigned int badpages[1]; |
| }; |
| |
| struct unixware_slice { |
| unsigned short slice_type; |
| unsigned short slice_flags; |
| unsigned int start; |
| unsigned int size; |
| }; |
| |
| struct bsd_disklabel { |
| uchar d_magic[4]; |
| uchar d_stuff1[4]; |
| uchar d_typename[16]; /* type name, e.g. "eagle" */ |
| uchar d_packname[16]; /* pack identifier */ |
| uint32 d_secsize; /* # of bytes per sector */ |
| uint32 d_nsectors; /* # of data sectors per track */ |
| uint32 d_ntracks; /* # of tracks per cylinder */ |
| uint32 d_ncylinders; /* # of data cylinders per unit */ |
| uint32 d_secpercyl; /* # of data sectors per cylinder */ |
| uint32 d_secperunit; /* # of data sectors per unit */ |
| uchar d_stuff2[68]; |
| uchar d_magic2[4]; /* the magic number (again) */ |
| uint16 d_checksum; /* xor of data incl. partitions */ |
| |
| /* filesystem and partition information: */ |
| uint16 d_npartitions; /* number of partitions in following */ |
| uint32 d_bbsize; /* size of boot area at sn0, bytes */ |
| uint32 d_sbsize; /* max size of fs superblock, bytes */ |
| struct bsd_partition { /* the partition table */ |
| uint32 p_size; /* number of sectors in partition */ |
| uint32 p_offset; /* starting sector */ |
| uchar p_stuff[8]; |
| } d_partitions[16]; /* 16 is for openbsd */ |
| }; |
| |
| |
| int |
| main(int argc, char **argv){ |
| int i,j,fd; |
| long size; |
| int pagesize, pagesecs; |
| unsigned char *bp; |
| struct ext2_super_block *e2bp; |
| struct fat16_boot_sector *fat16bs; |
| struct fat32_boot_sector *fat32bs; |
| |
| progname = argv[0]; |
| |
| if (argc != 2) { |
| fprintf(stderr, "call: %s device\n", progname); |
| exit(1); |
| } |
| |
| device = argv[1]; |
| |
| fd = open(device, O_RDONLY); |
| if (fd < 0) { |
| perror(device); |
| fprintf(stderr, "%s: could not open %s\n", progname, device); |
| exit(1); |
| } |
| |
| if (ioctl(fd, BLKGETSIZE, &size)) { |
| struct stat s; |
| perror("BLKGETSIZE"); |
| fprintf(stderr, "%s: could not get device size\n", progname); |
| if (stat(device, &s)) { |
| fprintf(stderr, "and also stat fails. Aborting.\n"); |
| exit(1); |
| } |
| size = s.st_size / 512; |
| } |
| |
| pagesize = getpagesize(); |
| if (pagesize <= 0) |
| pagesize = 4096; |
| else if (pagesize > MAXPAGESZ) { |
| fprintf(stderr, "%s: ridiculous pagesize %d\n", progname, pagesize); |
| exit(1); |
| } |
| pagesecs = pagesize/512; |
| |
| printf("# partition table of %s\n", device); |
| printf("# total size %d sectors\n", size); |
| printf("unit: sectors\n"); |
| |
| for(i=0; i<size; i++) { |
| if (i/BUFSECS != bufstart) { |
| int len, secno; |
| bufstart = i/BUFSECS; |
| secno = bufstart*BUFSECS; |
| len = BUFSECS; |
| if (size - secno < len) |
| len = size - secno; |
| len = (len / 2)*2; /* avoid reading the last (odd) sector */ |
| read_sectors(fd, buf, secno, len); |
| } |
| |
| j = i % BUFSECS; |
| |
| bp = buf + 512 * j; |
| |
| if (bp[510] == 0x55 && bp[511] == 0xAA) { |
| char *cp = bp+512-2-64; |
| int j; |
| |
| if (i==0) |
| continue; /* the MBR is supposed to be broken */ |
| |
| /* Unfortunately one finds extended partition table sectors |
| that look just like a fat boot sector, except that the |
| partition table bytes have been overwritten */ |
| /* typical FAT32 end: "nd then press ...", followed by |
| IO.SYS and MSDOS.SYS and WINBOOT.SYS directory entries. |
| typical extd part tab end: 2 entries, 32 nul bytes */ |
| |
| for(j=0; j<32; j++) |
| if (cp[32+j]) |
| goto nonzero; |
| addepts(i, bp); |
| if (i > 0) { |
| j = create_extended_partition(fd, i, size); |
| if (j && j > i) |
| i = j; /* skip */ |
| } |
| continue; |
| nonzero: |
| fat16bs = (struct fat16_boot_sector *) bp; |
| if (fat16bs->s.media == 0xf8 && |
| fat16bs->m.extd_signature == 0x29 && |
| !strncmp(fat16bs->m.fs_name, "FAT", 3)) { |
| int lth; |
| lth = fat16bs->s.sectors[0] + |
| fat16bs->s.sectors[1]*256; |
| if (lth) { |
| outmsg("small fat partition", i, i+lth, 0x1); |
| addpart(i, lth, 0x1); |
| } else { |
| lth = fat16bs->s.total_sect; |
| outmsg("fat partition", i, i+lth, 0x6); |
| addpart(i, lth, 0x6); |
| } |
| i = i+lth-1; /* skip */ |
| continue; |
| } |
| |
| fat32bs = (struct fat32_boot_sector *) bp; |
| if (fat32bs->s.media == 0xf8 && |
| fat32bs->m.extd_signature == 0x29 && |
| !strncmp(fat32bs->m.fs_name, "FAT32 ", 8)) { |
| int lth = fat32bs->s.total_sect; |
| outmsg("fat32 partition", i, i+lth, 0xb); /* or 0xc */ |
| addpart(i, lth, 0xb); |
| i = i+lth-1; /* skip */ |
| continue; |
| } |
| } |
| |
| if (!strncmp(bp+502, "SWAP-SPACE", 10)) { |
| char *last; |
| int ct; |
| int ss = i-pagesecs+1; |
| int es; |
| char buf2[MAXPAGESZ]; |
| |
| read_sectors(fd, buf2, ss, pagesecs); |
| for (last = buf2+pagesize-10-1; last > buf2; last--) |
| if (*last) |
| break; |
| for (ct = 7; ct >= 0; ct--) |
| if (*last & (1<<ct)) |
| break; |
| es = ((last - buf2)*8 + ct + 1)*pagesecs + ss; |
| if (es <= size) { |
| outmsg("old swap space", ss, es, 0x82); |
| addpart(ss, es-ss, 0x82); |
| |
| i = es-1; /* skip */ |
| continue; |
| } |
| } |
| |
| if (!strncmp(bp+502, "SWAPSPACE2", 10)) { |
| int ss = i-pagesecs+1; |
| int es, lth; |
| char buf2[MAXPAGESZ]; |
| struct swap_header_v1 *p; |
| |
| read_sectors(fd, buf2, ss, pagesecs); |
| p = (struct swap_header_v1 *) buf2; |
| lth = (p->last_page + 1)* pagesecs; |
| es = ss + lth; |
| if (es <= size) { |
| outmsg("new swap space", ss, es, 0x82); |
| addpart(ss, lth, 0x82); |
| |
| i = es-1; /* skip */ |
| continue; |
| } |
| } |
| |
| e2bp = (struct ext2_super_block *) bp; |
| if (e2bp->s_magic == EXT2_SUPER_MAGIC && is_time(e2bp->s_mtime) |
| && is_time(e2bp->s_wtime) && is_ztime(e2bp->s_lastcheck) |
| && e2bp->s_log_block_size <= 10 /* at most 1 MB blocks */) { |
| char buf[512]; |
| struct ext2_super_block *bp2; |
| int ss, sz, es, gsz, j; |
| |
| ss = i-2; |
| sz = (e2bp->s_blocks_count << (e2bp->s_log_block_size + 1)); |
| gsz = (e2bp->s_blocks_per_group << (e2bp->s_log_block_size + 1)); |
| if (e2bp->s_block_group_nr > 0) |
| ss -= gsz * e2bp->s_block_group_nr; |
| es = ss + sz; |
| if (ss > 0 && es > i && es <= size) { |
| if (e2bp->s_block_group_nr == 0) { |
| outmsg("ext2 partition", ss, es, 0x83); |
| addpart(ss, es-ss, 0x83); |
| |
| i = es-1; /* skip */ |
| continue; |
| } |
| |
| /* maybe we jumped into the middle of a partially |
| obliterated ext2 partition? */ |
| |
| printf("# sector %d looks like an ext2 superblock copy #%d;\n" |
| "# in a partition covering sectors %d-%d\n", |
| i, e2bp->s_block_group_nr, ss, es-1); |
| |
| for (j=1; j<=e2bp->s_block_group_nr; j++) { |
| read_sectors(fd, buf, i-j*gsz, 1); |
| bp2 = (struct ext2_super_block *) buf; |
| if (bp2->s_magic != EXT2_SUPER_MAGIC || |
| bp2->s_block_group_nr != |
| e2bp->s_block_group_nr - j) |
| break; |
| } |
| if (j == 1) |
| printf("# however, sector %d doesnt look like a sb.\n", |
| i-gsz); |
| else if (j <= e2bp->s_block_group_nr) |
| printf("# also the preceding %d block groups seem OK\n" |
| "# but before that things seem to be wrong.\n", |
| j-1); |
| else { |
| printf("# found all preceding superblocks OK\n" |
| "# Warning: overlapping partitions?\n"); |
| outmsg("ext2 partition", ss, es, 0x83); |
| addpart(ss, es-ss, 0x83); |
| i = es-1; /* skip */ |
| continue; |
| } |
| } |
| |
| } |
| |
| if (bp[4] == 0x0d && bp[5] == 0x60 && |
| bp[6] == 0x5e && bp[7] == 0xca && /* CA5E600D */ |
| bp[156] == 0xee && bp[157] == 0xde && |
| bp[158] == 0x0d && bp[159] == 0x60) /* 600DDEEE */ { |
| int ss, es; |
| struct unixware_slice *u; |
| printf("# Unixware partition seen\n"); |
| u = (struct unixware_slice *)(bp + 216); |
| if (u->slice_type == 5 /* entire disk */ |
| && (u->slice_flags & 0x200)) /* valid */ { |
| ss = u->start; |
| es = u->start + u->size; |
| outmsg("Unixware ptn", ss, es, 0x63); |
| addpart(ss, es-ss, 0x63); |
| i = es-1; |
| continue; |
| } else |
| printf("# Unrecognized details\n"); |
| } |
| |
| /* bsd disk magic 0x82564557UL */ |
| if (bp[0] == 0x57 && bp[1] == 0x45 && bp[2] == 0x56 && bp[3] == 0x82) { |
| int ss, es, npts, j; |
| struct bsd_disklabel *l; |
| struct bsd_partition *p; |
| printf("# BSD magic seen in sector %d\n", i); |
| l = (struct bsd_disklabel *) bp; |
| if (l->d_magic2[0] != 0x57 || l->d_magic2[1] != 0x45 || |
| l->d_magic2[2] != 0x56 || l->d_magic2[3] != 0x82) |
| printf("# 2nd magic bad - ignored this sector\n"); |
| else if ((npts = l->d_npartitions) > 16) |
| printf("# strange number (%d) of subpartitions - " |
| "ignored this sector\n", npts); |
| else { |
| for (j=0; j<npts; j++) { |
| p = &(l->d_partitions[j]); |
| if (p->p_size) |
| printf("# part %c: size %9d, start %9d\n", |
| 'a'+j, p->p_size, p->p_offset); |
| } |
| ss = l->d_partitions[2].p_offset; |
| es = ss + l->d_partitions[2].p_size; |
| if (ss != i-1) |
| printf("# strange start of whole disk - " |
| "ignored this sector\n"); |
| else { |
| /* FreeBSD 0xa5, OpenBSD 0xa6, NetBSD 0xa9, BSDI 0xb7 */ |
| /* How to distinguish? */ |
| outmsg("BSD partition", ss, es, 0xa5); |
| addpart(ss, es-ss, 0xa5); |
| i = es-1; |
| continue; |
| } |
| } |
| } |
| } |
| |
| outparts(); |
| |
| exit(0); |
| } |
| |