static int cmd_create(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
int unnamedargs;
const imgtool_module *module;
option_resolution *resolution = NULL;
module = imgtool_find_module(argv[0]);
if (!module)
{
err = (imgtoolerr_t)(IMGTOOLERR_MODULENOTFOUND | IMGTOOLERR_SRC_MODULE);
goto error;
}
if (module->createimage_optguide && module->createimage_optspec)
{
resolution = option_resolution_create(module->createimage_optguide, module->createimage_optspec);
if (!resolution)
{
err = IMGTOOLERR_OUTOFMEMORY;
goto error;
}
}
unnamedargs = parse_options(argc, argv, 2, 3, resolution, NULL, NULL);
if (unnamedargs < 0)
return -1;
err = imgtool_image_create(module, argv[1], resolution, NULL);
if (err)
goto error;
if (resolution)
option_resolution_close(resolution);
return 0;
error:
if (resolution)
option_resolution_close(resolution);
reporterror(err, c, argv[0], argv[1], NULL, NULL, 0);
return -1;
}
floperr_t floppy_format_track(floppy_image *floppy, int head, int track, option_resolution *parameters)
{
floperr_t err;
struct FloppyCallbacks *format;
option_resolution *alloc_resolution = NULL;
optreserr_t oerr;
/* supported? */
format = floppy_callbacks(floppy);
if (!format->format_track)
{
err = FLOPPY_ERROR_UNSUPPORTED;
goto done;
}
/* create a dummy resolution; if no parameters were specified */
if (!parameters)
{
alloc_resolution = option_resolution_create(floppy_option_guide, floppy->floppy_option->param_guidelines);
if (!alloc_resolution)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
goto done;
}
parameters = alloc_resolution;
}
oerr = option_resolution_finish(parameters);
if (oerr)
{
err = option_to_floppy_error(oerr);
goto done;
}
err = format->format_track(floppy, head, track, parameters);
if (err)
goto done;
done:
if (alloc_resolution)
option_resolution_close(alloc_resolution);
return err;
}
imgtoolerr_t win_show_option_dialog(HWND parent, struct transfer_suggestion_info *suggestion_info,
const struct OptionGuide *guide, const char *optspec,
option_resolution **result, BOOL *cancel)
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
option_resolution *res = NULL;
struct putfileopt_info pfo_info;
int rc;
*cancel = FALSE;
if (guide)
{
res = option_resolution_create(guide, optspec);
if (!res)
{
err = IMGTOOLERR_OUTOFMEMORY;
goto done;
}
}
pfo_info.resolution = res;
pfo_info.guide = guide;
pfo_info.optspec = optspec;
pfo_info.suggestion_info = suggestion_info;
rc = DialogBoxParam(NULL, MAKEINTRESOURCE(IDD_FILEOPTIONS), parent,
putfileopt_dialogproc, (LPARAM) &pfo_info);
*cancel = (rc == IDCANCEL);
done:
if (err && res)
{
option_resolution_close(res);
res = NULL;
}
*result = res;
return err;
}
option_resolution *option_resolution_create(const option_guide *guide, const char *specification)
{
option_resolution *resolution = nullptr;
const option_guide *guide_entry;
int option_count;
int opt = -1;
object_pool *pool;
assert(guide);
/* first count the number of options specified in the guide */
option_count = option_resolution_countoptions(guide, specification);
/* create a memory pool for this structure */
pool = pool_alloc_lib(nullptr);
if (!pool)
goto outofmemory;
/* allocate the main structure */
resolution = (option_resolution *)pool_malloc_lib(pool, sizeof(option_resolution));
if (!resolution)
goto outofmemory;
memset(resolution, 0, sizeof(*resolution));
resolution->pool = pool;
/* set up the entries list */
resolution->option_count = option_count;
resolution->specification = specification;
resolution->entries = (option_resolution_entry *)pool_malloc_lib(resolution->pool, sizeof(struct option_resolution_entry) * option_count);
if (!resolution->entries)
goto outofmemory;
memset(resolution->entries, 0, sizeof(struct option_resolution_entry) * option_count);
/* initialize each of the entries */
opt = 0;
guide_entry = guide;
while(guide_entry->option_type != OPTIONTYPE_END)
{
switch(guide_entry->option_type) {
case OPTIONTYPE_INT:
case OPTIONTYPE_ENUM_BEGIN:
case OPTIONTYPE_STRING:
if (lookup_in_specification(specification, guide_entry))
resolution->entries[opt++].guide_entry = guide_entry;
break;
case OPTIONTYPE_ENUM_VALUE:
break;
default:
goto unexpected;
}
guide_entry++;
}
assert(opt == option_count);
return resolution;
unexpected:
assert(FALSE);
outofmemory:
if (resolution)
option_resolution_close(resolution);
return nullptr;
}
static void node_createimage(struct imgtooltest_state *state, xml_data_node *node)
{
imgtoolerr_t err;
xml_data_node *child_node;
xml_attribute_node *attr_node;
option_resolution *opts = NULL;
const imgtool_module *module;
const char *driver;
const char *param_name;
const char *param_value;
attr_node = xml_get_attribute(node, "driver");
if (!attr_node)
{
error_missingattribute("driver");
return;
}
driver = attr_node->value;
/* does image creation support options? */
module = imgtool_find_module(attr_node->value);
if (module && module->createimage_optguide && module->createimage_optspec)
opts = option_resolution_create(module->createimage_optguide, module->createimage_optspec);
report_message(MSG_INFO, "Creating image (module '%s')", driver);
for (child_node = xml_get_sibling(node->child, "param"); child_node; child_node = xml_get_sibling(child_node->next, "param"))
{
if (!opts)
{
report_message(MSG_FAILURE, "Cannot specify creation options with this module");
return;
}
attr_node = xml_get_attribute(child_node, "name");
if (!attr_node)
{
error_missingattribute("name");
return;
}
param_name = attr_node->value;
attr_node = xml_get_attribute(child_node, "value");
if (!attr_node)
{
error_missingattribute("value");
return;
}
param_value = attr_node->value;
option_resolution_add_param(opts, param_name, param_value);
}
err = imgtool_image_create_byname(driver, tempfile_name(), opts, &state->m_image);
if (opts)
{
option_resolution_close(opts);
opts = NULL;
}
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
err = imgtool_partition_open(state->m_image, 0, &state->m_partition);
if (err)
{
state->m_failed = 1;
report_imgtoolerr(err);
return;
}
}
static int cmd_put(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err = IMGTOOLERR_SUCCESS;
int i;
imgtool_image *image = NULL;
imgtool_partition *partition = NULL;
const char *filename = NULL;
int unnamedargs;
filter_getinfoproc filter;
const imgtool_module *module;
option_resolution *resolution = NULL;
const char *fork;
const char *new_filename;
char **filename_list;
int filename_count;
int partition_index = 0;
const option_guide *writefile_optguide;
const char *writefile_optspec;
module = imgtool_find_module(argv[0]);
if (!module)
{
err = (imgtoolerr_t)(IMGTOOLERR_MODULENOTFOUND | IMGTOOLERR_SRC_MODULE);
goto done;
}
/* ugh I hate the way this function is set up, this is because the
* arguments depend on the partition; something that requires some
* rudimentary parsing */
if (argc >= 2)
{
/* open up the image */
err = imgtool_image_open(module, argv[1], OSD_FOPEN_RW, &image);
if (err)
goto done;
/* open up the partition */
err = imgtool_partition_open(image, partition_index, &partition);
if (err)
goto done;
writefile_optguide = (const option_guide *) imgtool_partition_get_info_ptr(partition, IMGTOOLINFO_PTR_WRITEFILE_OPTGUIDE);
writefile_optspec = (const char *)imgtool_partition_get_info_ptr(partition, IMGTOOLINFO_STR_WRITEFILE_OPTSPEC);
if (writefile_optguide && writefile_optspec)
{
resolution = option_resolution_create(writefile_optguide, writefile_optspec);
if (!resolution)
{
err = IMGTOOLERR_OUTOFMEMORY;
goto done;
}
}
}
unnamedargs = parse_options(argc, argv, 4, 0xffff, resolution, &filter, &fork);
if (unnamedargs < 0)
return -1;
/* pick out which args are filenames, and which one is the destination */
new_filename = interpret_filename(argv[unnamedargs - 1]);
filename_list = &argv[2];
filename_count = unnamedargs - 3;
/* loop through the filenames, and put them */
for (i = 0; i < filename_count; i++)
{
filename = filename_list[i];
printf("Putting file '%s'...\n", filename);
err = imgtool_partition_put_file(partition, new_filename, fork, filename, resolution, filter);
if (err)
goto done;
}
done:
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (resolution)
option_resolution_close(resolution);
if (err)
reporterror(err, c, argv[0], argv[1], filename, NULL, resolution);
return err ? -1 : 0;
}
floperr_t floppy_create(void *fp, const struct io_procs *procs, const struct FloppyFormat *format, option_resolution *parameters, floppy_image **outfloppy)
{
floppy_image *floppy = NULL;
optreserr_t oerr;
floperr_t err;
int heads, tracks, h, t;
option_resolution *alloc_resolution = NULL;
assert(format);
/* create the new image */
floppy = floppy_init(fp, procs, 0);
if (!floppy)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
goto done;
}
/* if this format expects creation parameters and none were specified, create some */
if (!parameters && floppy_option_guide && format->param_guidelines)
{
alloc_resolution = option_resolution_create(floppy_option_guide, format->param_guidelines);
if (!alloc_resolution)
{
err = FLOPPY_ERROR_OUTOFMEMORY;
goto done;
}
parameters = alloc_resolution;
}
/* finish the parameters, if specified */
if (parameters)
{
oerr = option_resolution_finish(parameters);
if (oerr)
{
err = option_to_floppy_error(oerr);
goto done;
}
}
/* call the format constructor */
err = format->construct(floppy, format, parameters);
if (err)
goto done;
/* format the disk, ignoring if formatting not implemented */
if (floppy->format.format_track)
{
heads = floppy_get_heads_per_disk(floppy);
tracks = floppy_get_tracks_per_disk(floppy);
for (h = 0; h < heads; h++)
{
for (t = 0; t < tracks; t++)
{
err = floppy->format.format_track(floppy, h, t, parameters);
if (err)
goto done;
}
}
}
/* call the post_format function, if present */
if (floppy->format.post_format)
{
err = floppy->format.post_format(floppy, parameters);
if (err)
goto done;
}
floppy->floppy_option = format;
err = FLOPPY_ERROR_SUCCESS;
done:
if (err && floppy)
{
floppy_close_internal(floppy, FALSE);
floppy = NULL;
}
if (outfloppy)
*outfloppy = floppy;
else if (floppy)
floppy_close_internal(floppy, FALSE);
if (alloc_resolution)
option_resolution_close(alloc_resolution);
return err;
}
