static int xbsd_writelabel(struct partition *p) { struct xbsd_disklabel *d = &xbsd_dlabel; unsigned int sector; #if !defined(__alpha__) && !defined(__powerpc__) && !defined(__hppa__) sector = get_start_sect(p) + BSD_LABELSECTOR; #else (void)p; /* silence warning */ sector = BSD_LABELSECTOR; #endif d->d_checksum = 0; d->d_checksum = xbsd_dkcksum(d); /* This is necessary if we want to write the bootstrap later, otherwise we'd write the old disklabel with the bootstrap. */ memmove(&disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], d, sizeof(struct xbsd_disklabel)); #if defined(__alpha__) && BSD_LABELSECTOR == 0 alpha_bootblock_checksum(disklabelbuffer); seek_sector(0); xwrite(dev_fd, disklabelbuffer, BSD_BBSIZE); #else seek_sector(sector); lseek(dev_fd, BSD_LABELOFFSET, SEEK_CUR); xwrite(dev_fd, d, sizeof(*d)); #endif sync_disks(); return 1; }
void read_sector_n(const unsigned int cylinder, const unsigned int sector, unsigned char* buffer, const size_t n){ int i; if( !seek_sector(cylinder, sector) ){ buffer = NULL; return; } /* Mettre dans MASTERBUFFER les donnees a cette emplacement */ _out(HDA_DATAREGS, 1); _out(HDA_CMDREG, CMD_READ); _sleep(HDA_IRQ); /* exploiter les donnees de MASTERBUFFER */ for(i=0; i<HDA_SECTORSIZE && i<n; i++){ buffer[i] = (unsigned char)MASTERBUFFER[i]; } }
void read_sector(unsigned int cylinder, unsigned int sector, unsigned char* buffer){ int secteur_size; int tmp, i; if( !seek_sector(cylinder, sector) ){ buffer = NULL; return; } /* Mettre dans MASTERBUFFER les donnees a cette emplacement */ _out(HDA_DATAREGS, 1); _out(HDA_CMDREG, CMD_READ); _sleep(HDA_IRQ); /* exploiter les donnees de MASTERBUFFER */ _out(HDA_CMDREG, CMD_DSKINFO); tmp = _in(HDA_DATAREGS+4); tmp = tmp<<8; secteur_size = tmp + _in(HDA_DATAREGS+5); for(i=0; i<secteur_size; i++){ buffer[i] = (unsigned char)MASTERBUFFER[i]; } buffer[++i] = EOF; }
static DVDA_Packet_Reader* open_packet_reader(DVDA_Sector_Reader* sectors, unsigned start_sector, unsigned end_sector) { DVDA_Packet_Reader* packets = malloc(sizeof(DVDA_Packet_Reader)); assert(end_sector >= start_sector); packets->start_sector = start_sector; packets->end_sector = end_sector; packets->sectors = sectors; packets->reader = br_substream_new(BS_BIG_ENDIAN); packets->total_sectors = end_sector - start_sector; seek_sector(sectors, start_sector); return packets; }
static int read_sector(DVDA_Sector_Reader* reader, struct bs_buffer* sector) { if (reader->current.sector <= reader->end_sector) { DVDA_AOB* aob = reader->current.aob; static uint8_t sector_data[SECTOR_SIZE]; const size_t bytes_read = fread(sector_data, sizeof(uint8_t), SECTOR_SIZE, aob->file); buf_write(sector, sector_data, (uint32_t)bytes_read); if (bytes_read == SECTOR_SIZE) { /*sector read successfully*/ #ifdef HAS_UNPROT /*unprotect if necessary*/ if (reader->cppm_decoder != NULL) { cppm_decrypt(reader->cppm_decoder, sector_data, 1, 1); } #endif /*then move on to next sector*/ reader->current.sector++; if (reader->current.sector > aob->end_sector) { /*move on to next AOB in set, if any*/ if (reader->current.sector <= reader->end_sector) { seek_sector(reader, reader->current.sector); } } return 0; } else { /*I/O error reading sector*/ return 1; } } else { /*no more sectors to read, so return EOF*/ return 0; } }
void format_sector(const unsigned int cylinder, const unsigned int sector, const unsigned int nsector, const unsigned int value){ if( !seek_sector(cylinder, sector) ){ return; } _out(HDA_DATAREGS, (nsector>>8 & 0xFF) ); _out(HDA_DATAREGS+1, (nsector & 0xFF) ); _out(HDA_DATAREGS+2, (value>>24 & 0xFF) ); _out(HDA_DATAREGS+3, (value>>16 & 0xFF) ); _out(HDA_DATAREGS+4, (value>>8 & 0xFF) ); _out(HDA_DATAREGS+5, (value & 0xFF) ); _out(HDA_CMDREG, CMD_FORMAT); _sleep(HDA_IRQ); }
/* * Read a xbsd_disklabel from sector 0 or from the starting sector of p. * If it has the right magic, return 1. */ static int xbsd_readlabel(struct partition *p) { struct xbsd_disklabel *d; int t, sector; if (!bsd_globals_ptr) bsd_globals_ptr = xzalloc(sizeof(*bsd_globals_ptr)); d = &xbsd_dlabel; /* p is used only to get the starting sector */ #if !defined(__alpha__) sector = (p ? get_start_sect(p) : 0); #else sector = 0; #endif seek_sector(sector); if (BSD_BBSIZE != full_read(dev_fd, disklabelbuffer, BSD_BBSIZE)) fdisk_fatal(unable_to_read); memmove(d, &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE + BSD_LABELOFFSET], sizeof(struct xbsd_disklabel)); if (d->d_magic != BSD_DISKMAGIC || d->d_magic2 != BSD_DISKMAGIC) return 0; for (t = d->d_npartitions; t < BSD_MAXPARTITIONS; t++) { d->d_partitions[t].p_size = 0; d->d_partitions[t].p_offset = 0; d->d_partitions[t].p_fstype = BSD_FS_UNUSED; } if (d->d_npartitions > BSD_MAXPARTITIONS) printf("Warning: too many partitions (%u, maximum is %u)\n", d->d_npartitions, BSD_MAXPARTITIONS); return 1; }
void write_sector(unsigned int cylinder, unsigned int sector, unsigned char* buffer){ int i; int length; if( !seek_sector(cylinder, sector) ){ buffer = NULL; return; } /* ecrire les donnees dans MASTERBUFFER */ length = strlen((char*)buffer); for(i=0; i<length || i< HDA_SECTORSIZE; i++){ MASTERBUFFER[i] = buffer[i]; } /* Mettre dans le disque les donnees de MASTERBUFFER */ _out(HDA_DATAREGS, 0); _out(HDA_DATAREGS, 1); _out(HDA_CMDREG, CMD_WRITE); _sleep(HDA_IRQ); }
void write_sector_n(const unsigned int cylinder, const unsigned int sector, const unsigned char* buffer, const size_t n){ int i; if( !seek_sector(cylinder, sector) ){ buffer = NULL; return; } /* ecrire les donnees dans MASTERBUFFER */ for(i=0; i<HDA_SECTORSIZE && i<n; i++){ MASTERBUFFER[i] = buffer[i]; } /* Mettre dans le disque les donnees de MASTERBUFFER */ _out(HDA_DATAREGS, 0); _out(HDA_DATAREGS, 1); _out(HDA_CMDREG, CMD_WRITE); _sleep(HDA_IRQ); }
static void xbsd_write_bootstrap(void) { char path[MAXPATHLEN]; const char *bootdir = BSD_LINUX_BOOTDIR; const char *dkbasename; struct xbsd_disklabel dl; char *d, *p, *e; int sector; if (xbsd_dlabel.d_type == BSD_DTYPE_SCSI) dkbasename = "sd"; else dkbasename = "wd"; snprintf(path, sizeof(path), "Bootstrap: %sboot -> boot%s (%s): ", dkbasename, dkbasename, dkbasename); if (read_line(path)) { dkbasename = line_ptr; } snprintf(path, sizeof(path), "%s/%sboot", bootdir, dkbasename); if (!xbsd_get_bootstrap(path, disklabelbuffer, (int) xbsd_dlabel.d_secsize)) return; /* We need a backup of the disklabel (xbsd_dlabel might have changed). */ d = &disklabelbuffer[BSD_LABELSECTOR * SECTOR_SIZE]; memmove(&dl, d, sizeof(struct xbsd_disklabel)); /* The disklabel will be overwritten by 0's from bootxx anyway */ memset(d, 0, sizeof(struct xbsd_disklabel)); snprintf(path, sizeof(path), "%s/boot%s", bootdir, dkbasename); if (!xbsd_get_bootstrap(path, &disklabelbuffer[xbsd_dlabel.d_secsize], (int) xbsd_dlabel.d_bbsize - xbsd_dlabel.d_secsize)) return; e = d + sizeof(struct xbsd_disklabel); for (p = d; p < e; p++) if (*p) { printf("Bootstrap overlaps with disk label!\n"); exit(EXIT_FAILURE); } memmove(d, &dl, sizeof(struct xbsd_disklabel)); #if defined(__powerpc__) || defined(__hppa__) sector = 0; #elif defined(__alpha__) sector = 0; alpha_bootblock_checksum(disklabelbuffer); #else sector = get_start_sect(xbsd_part); #endif seek_sector(sector); xwrite(dev_fd, disklabelbuffer, BSD_BBSIZE); #if defined(__alpha__) printf("Bootstrap installed on %s\n", disk_device); #else printf("Bootstrap installed on %s\n", partname(disk_device, xbsd_part_index+1, 0)); #endif sync_disks(); }
static int check_gpt_label(void) { struct partition *first = pt_offset(MBRbuffer, 0); struct pte pe; uint32_t crc; /* LBA 0 contains the legacy MBR */ if (!valid_part_table_flag(MBRbuffer) || first->sys_ind != LEGACY_GPT_TYPE ) { current_label_type = 0; return 0; } /* LBA 1 contains the GPT header */ read_pte(&pe, 1); gpt_hdr = (void *)pe.sectorbuffer; if (gpt_hdr->magic != SWAP_LE64(GPT_MAGIC)) { current_label_type = 0; return 0; } if (!global_crc32_table) { global_crc32_table = crc32_filltable(NULL, 0); } crc = SWAP_LE32(gpt_hdr->hdr_crc32); gpt_hdr->hdr_crc32 = 0; if (gpt_crc32(gpt_hdr, SWAP_LE32(gpt_hdr->hdr_size)) != crc) { /* FIXME: read the backup table */ puts("\nwarning: GPT header CRC is invalid\n"); } n_parts = SWAP_LE32(gpt_hdr->n_parts); part_entry_len = SWAP_LE32(gpt_hdr->part_entry_len); if (n_parts > GPT_MAX_PARTS || part_entry_len > GPT_MAX_PART_ENTRY_LEN || SWAP_LE32(gpt_hdr->hdr_size) > sector_size ) { puts("\nwarning: unable to parse GPT disklabel\n"); current_label_type = 0; return 0; } part_array_len = n_parts * part_entry_len; part_array = xmalloc(part_array_len); seek_sector(SWAP_LE64(gpt_hdr->first_part_lba)); if (full_read(dev_fd, part_array, part_array_len) != part_array_len) { fdisk_fatal(unable_to_read); } if (gpt_crc32(part_array, part_array_len) != gpt_hdr->part_array_crc32) { /* FIXME: read the backup table */ puts("\nwarning: GPT array CRC is invalid\n"); } puts("Found valid GPT with protective MBR; using GPT\n"); current_label_type = LABEL_GPT; return 1; }