void
do_delete_partition(partition_map_header *map)
{
partition_map * cur;
long ix;
if (map == NULL) {
bad_input("No partition map exists");
return;
}
if (!rflag && map->writable == 0) {
printf("The map is not writable.\n");
}
if (get_number_argument("Partition number: ", &ix, kDefault) == 0) {
bad_input("Bad partition number");
return;
}
// find partition and delete it
cur = find_entry_by_disk_address(ix, map);
if (cur == NULL) {
printf("No such partition\n");
} else {
delete_partition_from_map(cur);
}
}
void
do_rename_partition(partition_map_header *map)
{
partition_map * entry;
long ix;
char *name;
if (map == NULL) {
bad_input("No partition map exists");
return;
}
if (!rflag && map->writable == 0) {
printf("The map is not writable.\n");
}
if (get_number_argument("Partition number: ", &ix, kDefault) == 0) {
bad_input("Bad partition number");
return;
}
if (get_string_argument("New name of partition: ", &name, 1) == 0) {
bad_input("Bad name");
return;
}
// find partition and change it
entry = find_entry_by_disk_address(ix, map);
if (entry == NULL) {
printf("No such partition\n");
} else {
// stuff name into partition map entry data
strncpy(entry->data->dpme_name, name, DPISTRLEN);
map->changed = 1;
}
free(name);
return;
}
int
get_size_argument(long *number, partition_map_header *map)
{
partition_map * entry;
int result = 0;
unsigned long multiple;
if (get_number_argument("Length in blocks: ", number, kDefault) == 0) {
bad_input("Bad length");
} else {
multiple = get_multiplier(map->logical_block);
if (multiple == 0) {
bad_input("Bad multiplier");
} else if (multiple != 1) {
*number *= multiple;
result = 1;
} else if (get_partition_modifier()) {
entry = find_entry_by_disk_address(*number, map);
if (entry == NULL) {
bad_input("Bad partition number");
} else {
*number = entry->data->dpme_pblocks;
result = 1;
}
} else {
result = 1;
}
}
return result;
}
void
do_reorder(partition_map_header *map)
{
long old_index;
long ix;
if (map == NULL) {
bad_input("No partition map exists");
return;
}
if (!rflag && map->writable == 0) {
printf("The map is not writable.\n");
}
if (get_number_argument("Partition number: ", &old_index, kDefault) == 0) {
bad_input("Bad partition number");
return;
}
if (get_number_argument("New number: ", &ix, kDefault) == 0) {
bad_input("Bad partition number");
return;
}
move_entry_in_map(old_index, ix, map);
}
void
do_change_map_size(partition_map_header *map)
{
long size;
if (map == NULL) {
bad_input("No partition map exists");
return;
}
if (!rflag && map->writable == 0) {
printf("The map is not writable.\n");
}
if (get_number_argument("New size: ", &size, kDefault) == 0) {
bad_input("Bad size");
return;
}
resize_map(size, map);
}
void
do_change_type(partition_map_header *map)
{
partition_map * entry;
long ix;
char *type = NULL;
if (map == NULL) {
bad_input("No partition map exists");
return;
}
if (!rflag && map->writable == 0) {
printf("The map is not writeable.\n");
}
if (get_number_argument("Partition number: ", &ix, kDefault) == 0) {
bad_input("Bad partition number");
return;
}
entry = find_entry_by_disk_address(ix, map);
if (entry == NULL ) {
printf("No such partition\n");
goto out;
}
printf("Existing partition type ``%s''.\n", entry->data->dpme_type);
if (get_string_argument("New type of partition: ", &type, 1) == 0) {
bad_input("Bad type");
goto out;
}
strncpy(entry->data->dpme_type, type, DPISTRLEN);
do_update_dpme(entry);
map->changed = 1;
out:
if (type)
free(type);
return;
}
void
do_display_entry(partition_map_header *map)
{
long number;
if (map == NULL) {
bad_input("No partition map exists");
return;
}
if (get_number_argument("Partition number: ", &number, kDefault) == 0) {
bad_input("Bad partition number");
return;
}
if (number == 0) {
full_dump_block_zero(map);
} else {
full_dump_partition_entry(map, number);
}
}
int
get_base_argument(long *number, partition_map_header *map)
{
partition_map * entry;
int result = 0;
if (get_number_argument("First block: ", number, kDefault) == 0) {
bad_input("Bad block number");
} else {
result = 1;
if (get_partition_modifier()) {
entry = find_entry_by_disk_address(*number, map);
if (entry == NULL) {
bad_input("Bad partition number");
result = 0;
} else {
*number = entry->data->dpme_pblock_start;
}
}
}
return result;
}
partition_map_header *
create_partition_map(char *name, partition_map_header *oldmap)
{
media *fd;
partition_map_header * map;
DPME *data;
unsigned long number;
int size;
#ifdef __linux__
struct stat info;
#endif
fd = open_media(name, (rflag)?O_RDONLY:O_RDWR);
if (fd == 0) {
error(errno, "can't open file '%s' for %sing", name,
(rflag)?"read":"writ");
return NULL;
}
map = (partition_map_header *) malloc(sizeof(partition_map_header));
if (map == NULL) {
error(errno, "can't allocate memory for open partition map");
close_media(fd);
return NULL;
}
map->fd = fd;
map->name = name;
map->writeable = (rflag)?0:1;
map->changed = 1;
map->disk_order = NULL;
map->base_order = NULL;
if (oldmap != NULL) {
size = oldmap->physical_block;
} else {
size = fd->block_size;
if (interactive) {
printf("A physical block is %d bytes: ", size);
flush_to_newline(0);
get_number_argument("what should be the physical block size? ",
(long *)&size, size);
size = (size / PBLOCK_SIZE) * PBLOCK_SIZE;
}
}
map->physical_block = size;
// printf("block size is %d\n", map->physical_block);
if (oldmap != NULL) {
size = oldmap->logical_block;
} else {
size = PBLOCK_SIZE;
if (interactive) {
printf("A logical block is %d bytes: ", size);
flush_to_newline(0);
get_number_argument("what should be the logical block size? ",
(long *)&size, size);
size = (size / PBLOCK_SIZE) * PBLOCK_SIZE;
}
}
map->logical_block = size;
if (map->logical_block > MAXIOSIZE) {
map->logical_block = MAXIOSIZE;
}
if (map->logical_block > map->physical_block) {
map->physical_block = map->logical_block;
}
map->blocks_in_map = 0;
map->maximum_in_map = -1;
number = compute_device_size(map, oldmap);
if (interactive) {
printf("size of 'device' is %lu blocks (%d byte blocks): ",
number, map->logical_block);
flush_to_newline(0);
get_number_argument("what should be the size? ",
(long *)&number, number);
if (number < 4) {
number = 4;
}
printf("new size of 'device' is %lu blocks (%d byte blocks)\n",
number, map->logical_block);
}
map->media_size = number;
#ifdef __linux__
if (fstat(fd, &info) < 0) {
error(errno, "can't stat file '%s'", name);
map->regular_file = 0;
} else {
map->regular_file = S_ISREG(info.st_mode);
}
#else
map->regular_file = 0;
#endif
map->misc = (Block0 *) malloc(PBLOCK_SIZE);
if (map->misc == NULL) {
error(errno, "can't allocate memory for block zero buffer");
} else {
// got it!
coerce_block0(map);
sync_device_size(map);
data = (DPME *) calloc(1, PBLOCK_SIZE);
if (data == NULL) {
error(errno, "can't allocate memory for disk buffers");
} else {
// set data into entry
data->dpme_signature = DPME_SIGNATURE;
data->dpme_map_entries = 1;
data->dpme_pblock_start = 1;
data->dpme_pblocks = map->media_size - 1;
strncpy(data->dpme_name, kFreeName, DPISTRLEN);
strncpy(data->dpme_type, kFreeType, DPISTRLEN);
data->dpme_lblock_start = 0;
data->dpme_lblocks = data->dpme_pblocks;
dpme_writable_set(data, 1);
dpme_readable_set(data, 1);
dpme_bootable_set(data, 0);
dpme_in_use_set(data, 0);
dpme_allocated_set(data, 0);
dpme_valid_set(data, 1);
if (add_data_to_map(data, 1, map) == 0) {
free(data);
} else {
return map;
}
}
}
close_partition_map(map);
return NULL;
}
//
// Routines
//
partition_map_header *
open_partition_map(char *name, int *valid_file, int ask_logical_size)
{
media *fd;
partition_map_header * map;
int writeable;
#ifdef __linux__
struct stat info;
#endif
int size;
fd = open_media(name, (rflag)?O_RDONLY:O_RDWR);
if (fd == 0) {
fd = open_media(name, O_RDONLY);
if (fd == 0) {
error(errno, "can't open file '%s'", name);
*valid_file = 0;
return NULL;
} else {
writeable = 0;
}
} else {
writeable = 1;
}
*valid_file = 1;
map = (partition_map_header *) malloc(sizeof(partition_map_header));
if (map == NULL) {
error(errno, "can't allocate memory for open partition map");
close_media(fd);
return NULL;
}
map->fd = fd;
map->name = name;
map->writeable = (rflag)?0:writeable;
map->changed = 0;
map->disk_order = NULL;
map->base_order = NULL;
map->physical_block = fd->block_size; /* preflight */
map->misc = (Block0 *) malloc(PBLOCK_SIZE);
if (map->misc == NULL) {
error(errno, "can't allocate memory for block zero buffer");
close_media(map->fd);
free(map);
return NULL;
} else if (read_media(map->fd, 0, (char *)map->misc, 0) == 0
|| convert_block0(map->misc, 1)
|| coerce_block0(map)) {
// if I can't read block 0 I might as well give up
close_partition_map(map);
return NULL;
}
map->physical_block = map->misc->sbBlkSize;
// printf("physical block size is %d\n", map->physical_block);
if (ask_logical_size && interactive) {
size = PBLOCK_SIZE;
printf("A logical block is %d bytes: ", size);
flush_to_newline(0);
get_number_argument("what should be the logical block size? ",
(long *)&size, size);
map->logical_block = (size / PBLOCK_SIZE) * PBLOCK_SIZE;
} else {
map->logical_block = PBLOCK_SIZE;
}
if (map->logical_block > MAXIOSIZE) {
map->logical_block = MAXIOSIZE;
}
if (map->logical_block > map->physical_block) {
map->physical_block = map->logical_block;
}
map->blocks_in_map = 0;
map->maximum_in_map = -1;
map->media_size = compute_device_size(map, map);
sync_device_size(map);
#ifdef __linux__
if (fstat(fd, &info) < 0) {
error(errno, "can't stat file '%s'", name);
map->regular_file = 0;
} else {
map->regular_file = S_ISREG(info.st_mode);
}
#else
map->regular_file = 0;
#endif
if (read_partition_map(map) < 0) {
// some sort of failure reading the map
} else {
// got it!
;
return map;
}
close_partition_map(map);
return NULL;
}
void
do_display_block(partition_map_header *map, char *alt_name)
{
MEDIA m;
long number;
char *name;
static unsigned char *display_block;
static int display_g;
int g;
static long next_number = -1;
if (map != NULL) {
name = 0;
m = map->m;
g = map->logical_block;
} else {
if (alt_name == 0) {
if (get_string_argument("Name of device: ", &name, 1) == 0) {
bad_input("Bad name");
return;
}
} else {
name = strdup(alt_name);
}
m = open_pathname_as_media(name, O_RDONLY);
if (m == 0) {
error(errno, "can't open file '%s'", name);
free(name);
return;
}
g = media_granularity(m);
if (g < PBLOCK_SIZE) {
g = PBLOCK_SIZE;
}
}
if (get_number_argument("Block number: ", &number, next_number) == 0) {
bad_input("Bad block number");
goto xit;
}
if (display_block == NULL || display_g < g) {
if (display_block != NULL) {
free(display_block);
display_g = 0;
}
display_block = (unsigned char *) malloc(g);
if (display_block == NULL) {
error(errno, "can't allocate memory for display block buffer");
goto xit;
}
display_g = g;
}
if (read_media(m, ((long long)number) * g, g, (char *)display_block) != 0) {
printf("block %ld -", number);
dump_block((unsigned char*) display_block, g);
next_number = number + 1;
}
xit:
if (name) {
close_media(m);
free(name);
}
return;
}
partition_map_header *
create_partition_map(char *name, partition_map_header *oldmap, int oflag)
{
MEDIA m;
partition_map_header * map;
DPME *data;
unsigned long default_number;
unsigned long number;
long size;
unsigned long multiple;
m = open_pathname_as_media(name, oflag);
if (m == 0) {
error(errno, "can't open file '%s' for %sing", name,
(oflag == O_RDONLY)?"read":"writ");
return NULL;
}
map = (partition_map_header *) malloc(sizeof(partition_map_header));
if (map == NULL) {
error(errno, "can't allocate memory for open partition map");
close_media(m);
return NULL;
}
map->name = name;
map->writable = (oflag == O_RDONLY)?0:1;
map->changed = 1;
map->disk_order = NULL;
map->base_order = NULL;
if (oldmap != NULL) {
size = oldmap->physical_block;
} else {
size = media_granularity(m);
}
m = open_deblock_media(PBLOCK_SIZE, m);
map->m = m;
if (interactive) {
printf("A physical block is %ld bytes: ", size);
flush_to_newline(0);
get_number_argument("what should be the physical block size? ",
&size, size);
size = (size / PBLOCK_SIZE) * PBLOCK_SIZE;
if (size < PBLOCK_SIZE) {
size = PBLOCK_SIZE;
}
}
if (map->physical_block > MAXIOSIZE) {
map->physical_block = MAXIOSIZE;
}
map->physical_block = size;
// printf("block size is %d\n", map->physical_block);
if (oldmap != NULL) {
size = oldmap->logical_block;
} else {
size = PBLOCK_SIZE;
}
if (interactive) {
printf("A logical block is %ld bytes: ", size);
flush_to_newline(0);
get_number_argument("what should be the logical block size? ",
&size, size);
size = (size / PBLOCK_SIZE) * PBLOCK_SIZE;
if (size < PBLOCK_SIZE) {
size = PBLOCK_SIZE;
}
}
#if 0
if (size > map->physical_block) {
size = map->physical_block;
}
#endif
map->logical_block = size;
map->blocks_in_map = 0;
map->maximum_in_map = -1;
number = compute_device_size(map, oldmap);
if (interactive) {
printf("size of 'device' is %lu blocks (%d byte blocks): ",
number, map->logical_block);
default_number = number;
flush_to_newline(0);
do {
if (get_number_argument("what should be the size? ",
(long *)&number, default_number) == 0) {
printf("Not a number\n");
flush_to_newline(1);
number = 0;
} else {
multiple = get_multiplier(map->logical_block);
if (multiple == 0) {
printf("Bad multiplier\n");
number = 0;
} else if (multiple != 1) {
if (0xFFFFFFFF/multiple < number) {
printf("Number too large\n");
number = 0;
} else {
number *= multiple;
}
}
}
default_number = kDefault;
} while (number == 0);
if (number < 4) {
number = 4;
}
printf("new size of 'device' is %lu blocks (%d byte blocks)\n",
number, map->logical_block);
}
map->media_size = number;
map->misc = (Block0 *) calloc(1, PBLOCK_SIZE);
if (map->misc == NULL) {
error(errno, "can't allocate memory for block zero buffer");
} else {
// got it!
coerce_block0(map);
sync_device_size(map);
data = (DPME *) calloc(1, PBLOCK_SIZE);
if (data == NULL) {
error(errno, "can't allocate memory for disk buffers");
} else {
// set data into entry
data->dpme_signature = DPME_SIGNATURE;
data->dpme_map_entries = 1;
data->dpme_pblock_start = 1;
data->dpme_pblocks = map->media_size - 1;
strncpy(data->dpme_name, kFreeName, DPISTRLEN);
strncpy(data->dpme_type, kFreeType, DPISTRLEN);
data->dpme_lblock_start = 0;
data->dpme_lblocks = data->dpme_pblocks;
dpme_writable_set(data, 1);
dpme_readable_set(data, 1);
dpme_bootable_set(data, 0);
dpme_in_use_set(data, 0);
dpme_allocated_set(data, 0);
dpme_valid_set(data, 1);
if (add_data_to_map(data, 1, map) == 0) {
free(data);
} else {
return map;
}
}
}
close_partition_map(map);
return NULL;
}
//
// Routines
//
partition_map_header *
open_partition_map(char *name, int *valid_file, int ask_logical_size, int oflag)
{
MEDIA m;
partition_map_header * map;
int writable;
long size;
m = open_pathname_as_media(name, oflag);
if (m == 0) {
m = open_pathname_as_media(name, O_RDONLY);
if (m == 0) {
error(errno, "can't open file '%s'", name);
*valid_file = 0;
return NULL;
} else {
writable = 0;
}
} else {
writable = 1;
}
*valid_file = 1;
map = (partition_map_header *) malloc(sizeof(partition_map_header));
if (map == NULL) {
error(errno, "can't allocate memory for open partition map");
close_media(m);
return NULL;
}
map->name = name;
map->writable = (oflag == O_RDONLY)?0:writable;
map->changed = 0;
map->written = 0;
map->disk_order = NULL;
map->base_order = NULL;
map->physical_block = media_granularity(m); /* preflight */
m = open_deblock_media(PBLOCK_SIZE, m);
map->m = m;
map->misc = (Block0 *) malloc(PBLOCK_SIZE);
if (map->misc == NULL) {
error(errno, "can't allocate memory for block zero buffer");
close_media(map->m);
free(map);
return NULL;
} else if (read_media(map->m, (long long) 0, PBLOCK_SIZE, (char *)map->misc) == 0
|| convert_block0(map->misc, 1)
|| coerce_block0(map)) {
// if I can't read block 0 I might as well give up
error(-1, "Can't read block 0 from '%s'", name);
close_partition_map(map);
return NULL;
}
map->physical_block = map->misc->sbBlkSize;
//printf("physical block size is %d\n", map->physical_block);
if (ask_logical_size && interactive) {
size = PBLOCK_SIZE;
printf("A logical block is %ld bytes: ", size);
flush_to_newline(0);
get_number_argument("what should be the logical block size? ",
&size, size);
size = (size / PBLOCK_SIZE) * PBLOCK_SIZE;
if (size < PBLOCK_SIZE) {
size = PBLOCK_SIZE;
}
map->logical_block = size;
} else {
map->logical_block = PBLOCK_SIZE;
}
if (map->logical_block > MAXIOSIZE) {
map->logical_block = MAXIOSIZE;
}
if (map->logical_block > map->physical_block) {
map->physical_block = map->logical_block;
}
map->blocks_in_map = 0;
map->maximum_in_map = -1;
map->media_size = compute_device_size(map, map);
if (read_partition_map(map) < 0) {
// some sort of failure reading the map
} else {
// got it!
;
return map;
}
close_partition_map(map);
return NULL;
}
