void LLFloaterWebContent::onOpen()
{
Params params(mKey);
if (!params.validateBlock())
{
close();
return;
}
mWebBrowser->setTrustedContent(params.trusted_content);
// tell the browser instance to load the specified URL
open_media(params);
}
void FloaterHop::onOpen(const LLSD& key)
{
Params params(key);
if (!params.validateBlock())
{
closeFloater();
return;
}
mWebBrowser->setTrustedContent(params.trusted_content);
// tell the browser instance to load the specified URL
open_media(params);
}
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;
}
void
write_partition_map(partition_map_header *map)
{
int fd;
char *block;
partition_map * entry;
int i = 0;
fd = map->fd->fd;
if (map->misc != NULL) {
convert_block0(map->misc, 0);
write_block(map, 0, (char *)map->misc);
convert_block0(map->misc, 1);
} else {
block = (char *) calloc(1, PBLOCK_SIZE);
if (block != NULL) {
write_block(map, 0, block);
free(block);
}
}
for (entry = map->disk_order; entry != NULL; entry = entry->next_on_disk) {
convert_dpme(entry->data, 0);
write_block(map, entry->disk_address, (char *)entry->data);
convert_dpme(entry->data, 1);
i = entry->disk_address;
}
#ifdef __linux__
// zap the block after the map (if possible) to get around a bug.
if (map->maximum_in_map > 0 && i < map->maximum_in_map) {
i += 1;
block = (char *) malloc(PBLOCK_SIZE);
if (block != NULL) {
if (read_block(map, i, block, 1)) {
block[0] = 0;
write_block(map, i, block);
}
free(block);
}
}
#endif /* __linux __ */
if (interactive)
printf("The partition table has been altered!\n\n");
#ifdef __linux__
if (map->regular_file) {
close_media(map->fd);
} else {
// printf("Calling ioctl() to re-read partition table.\n"
// "(Reboot to ensure the partition table has been updated.)\n");
sync();
sleep(2);
if ((i = ioctl(fd, BLKRRPART)) != 0) {
saved_errno = errno;
} else {
// some kernel versions (1.2.x) seem to have trouble
// rereading the partition table, but if asked to do it
// twice, the second time works. - [email protected] */
sync();
sleep(2);
if ((i = ioctl(fd, BLKRRPART)) != 0) {
saved_errno = errno;
}
}
close_media(map->fd);
// printf("Syncing disks.\n");
sync();
sleep(4); /* for sync() */
if (i < 0) {
error(saved_errno, "Re-read of partition table failed");
printf("Reboot your system to ensure the "
"partition table is updated.\n");
}
}
#else
close_media(map->fd);
#endif
map->fd = open_media(map->name, (map->writeable)?O_RDWR:O_RDONLY);
if (map->fd == 0) {
fatal(errno, "can't re-open file '%s' for %sing", map->name,
(rflag)?"read":"writ");
}
}
//
// 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;
}
