static int cmd_rmdir(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = NULL;
imgtool_partition *partition = NULL;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_RW, &image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
if (err)
goto done;
err = imgtool_partition_delete_directory(partition, argv[2]);
if (err)
goto done;
done:
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], argv[2], NULL, NULL);
return err ? -1 : 0;
}
void node_testimgtool(xml_data_node *node)
{
xml_data_node *child_node;
xml_attribute_node *attr_node;
struct imgtooltest_state state;
imgtool_init(FALSE, messtest_warn);
attr_node = xml_get_attribute(node, "name");
report_testcase_begin(attr_node ? attr_node->value : NULL);
memset(&state, 0, sizeof(state));
for (child_node = node->child; child_node; child_node = child_node->next)
{
if (!strcmp(child_node->name, "createimage"))
node_createimage(&state, child_node);
else if (!strcmp(child_node->name, "checkfile"))
node_checkfile(&state, child_node);
else if (!strcmp(child_node->name, "checkdirectory"))
node_checkdirectory(&state, child_node);
else if (!strcmp(child_node->name, "putfile"))
node_putfile(&state, child_node);
else if (!strcmp(child_node->name, "deletefile"))
node_deletefile(&state, child_node);
else if (!strcmp(child_node->name, "createdirectory"))
node_createdirectory(&state, child_node);
else if (!strcmp(child_node->name, "deletedirectory"))
node_deletedirectory(&state, child_node);
else if (!strcmp(child_node->name, "recordfreespace"))
node_recordfreespace(&state, child_node);
else if (!strcmp(child_node->name, "checkfreespace"))
node_checkfreespace(&state, child_node);
else if (!strcmp(child_node->name, "setattr"))
node_setattr(&state, child_node);
else if (!strcmp(child_node->name, "checkattr"))
node_checkattr(&state, child_node);
}
report_testcase_ran(state.failed);
/* close out any existing partition */
if (state.partition)
{
imgtool_partition_close(state.partition);
state.partition = NULL;
}
/* close out any existing image */
if (state.image)
{
imgtool_image_close(state.image);
state.image = NULL;
}
imgtool_exit();
}
static int cmd_getall(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = NULL;
imgtool_partition *partition = NULL;
imgtool_directory *imgenum = NULL;
imgtool_dirent ent;
filter_getinfoproc filter;
int unnamedargs;
const char *path = NULL;
int arg;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
if (err)
goto done;
arg = 2;
if ((argc > 2) && (argv[2][0] != '-'))
{
path = argv[arg++];
}
unnamedargs = parse_options(argc, argv, arg, arg, NULL, &filter, NULL);
if (unnamedargs < 0)
goto done;
err = imgtool_directory_open(partition, path, &imgenum);
if (err)
goto done;
memset(&ent, 0, sizeof(ent));
while (((err = imgtool_directory_get_next(imgenum, &ent)) == 0) && !ent.eof)
{
fprintf(stdout, "Retrieving %s (%u bytes)\n", ent.filename, (unsigned int) ent.filesize);
err = imgtool_partition_get_file(partition, ent.filename, NULL, NULL, filter);
if (err)
goto done;
}
done:
if (imgenum)
imgtool_directory_close(imgenum);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], NULL, NULL, NULL);
return err ? -1 : 0;
}
static int cmd_get(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
imgtool_image *image = NULL;
imgtool_partition *partition = NULL;
const char *filename;
char *new_filename;
int unnamedargs = 0;
filter_getinfoproc filter;
const char *fork;
int partition_index = 0;
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &image);
if (err)
goto done;
err = imgtool_partition_open(image, partition_index, &partition);
if (err)
goto done;
filename = interpret_filename(argv[2]);
unnamedargs = parse_options(argc, argv, 3, 4, NULL, &filter, &fork);
if (unnamedargs < 0)
goto done;
new_filename = (unnamedargs == 4) ? argv[3] : NULL;
err = imgtool_partition_get_file(partition, filename, fork, new_filename, filter);
if (err)
goto done;
err = IMGTOOLERR_SUCCESS;
done:
if (err)
reporterror(err, c, argv[0], argv[1], argv[2], argv[3], NULL);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
return (err || (unnamedargs < 0)) ? -1 : 0;
}
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;
}
static int cmd_dir(const struct command *c, int argc, char *argv[])
{
imgtoolerr_t err;
int total_count, total_size, freespace_err;
UINT64 freespace;
imgtool_image *image = NULL;
imgtool_partition *partition = NULL;
imgtool_directory *imgenum = NULL;
imgtool_dirent ent;
char buf[512];
char last_modified[19];
const char *path;
int partition_index = 0;
/* attempt to open image */
err = imgtool_image_open_byname(argv[0], argv[1], OSD_FOPEN_READ, &image);
if (err)
goto done;
/* attempt to open partition */
err = imgtool_partition_open(image, partition_index, &partition);
if (err)
goto done;
path = argc > 2 ? argv[2] : NULL;
err = imgtool_directory_open(partition, path, &imgenum);
if (err)
goto done;
memset(&ent, 0, sizeof(ent));
last_modified[0] = '\0';
total_count = 0;
total_size = 0;
fprintf(stdout, "Contents of %s:%s\n", argv[1], path ? path : "");
imgtool_image_info(image, buf, sizeof(buf));
if (buf[0])
fprintf(stdout, "%s\n", buf);
fprintf(stdout, "------------------------------ -------- --------------- ------------------\n");
while (((err = imgtool_directory_get_next(imgenum, &ent)) == 0) && !ent.eof)
{
if (ent.directory)
snprintf(buf, sizeof(buf), "<DIR>");
else
snprintf(buf, sizeof(buf), "%u", (unsigned int) ent.filesize);
if (ent.lastmodified_time != 0)
strftime(last_modified, sizeof(last_modified), "%d-%b-%y %H:%M:%S",
localtime(&ent.lastmodified_time));
if (ent.hardlink)
strcat(ent.filename, " <hl>");
fprintf(stdout, "%-30s %8s %15s %18s\n", ent.filename, buf, ent.attr, last_modified);
if (ent.softlink && ent.softlink[0] != '\0')
fprintf(stdout, "-> %s\n", ent.softlink);
if (ent.comment && ent.comment[0] != '\0')
fprintf(stdout, ": %s\n", ent.comment);
total_count++;
total_size += ent.filesize;
memset(&ent, 0, sizeof(ent));
}
freespace_err = imgtool_partition_get_free_space(partition, &freespace);
if (err)
goto done;
fprintf(stdout, "------------------------ ------ ---------------\n");
fprintf(stdout, "%8i File(s) %8i bytes\n", total_count, total_size);
if (!freespace_err)
fprintf(stdout, " %8u bytes free\n", (unsigned int) freespace);
done:
if (imgenum)
imgtool_directory_close(imgenum);
if (partition)
imgtool_partition_close(partition);
if (image)
imgtool_image_close(image);
if (err)
reporterror(err, c, argv[0], argv[1], NULL, NULL, NULL);
return err ? -1 : 0;
}
int cmd_testsuite(struct command *c, int argc, char *argv[])
{
const char *testsuitefile;
FILE *inifile;
const imgtool_module *module = NULL;
char buffer[1024];
char buffer2[1024];
char filename[1024];
char *filename_base;
size_t filename_len;
char *s;
char *s2;
const char *directive;
const char *directive_value;
imgtool_image *img = NULL;
imgtool_directory *imgenum;
imgtool_dirent imgdirent;
int err = -1, i;
testsuitefile = argv[0];
/* open the testsuite file */
inifile = fopen(testsuitefile, "r");
if (!inifile)
{
fprintf(stderr, "*** cannot open testsuite file '%s'\n", testsuitefile);
goto error;
}
/* change to the current directory of the test suite */
strncpyz(filename, testsuitefile, sizeof(filename));
s = filename + strlen(filename) - 1;
while((*s != '/') && (*s != '\\'))
*(s--) = '\0';
filename_base = s+1;
filename_len = filename_base - filename;
while(!feof(inifile))
{
buffer[0] = '\0';
fgets(buffer, sizeof(buffer) / sizeof(buffer[0]), inifile);
if (buffer[0] != '\0')
{
s = buffer + strlen(buffer) -1;
while(isspace(*s))
*(s--) = '\0';
}
s = buffer;
while(isspace(*s))
s++;
if (*s == '[')
{
s2 = strchr(s, ']');
if (!s2)
goto syntaxerror;
*s2 = '\0';
module = findimagemodule(s+1);
if (!module)
{
fprintf(stderr, "*** unrecognized imagemodule '%s'\n", s+1);
goto error;
}
imgtool_test(module);
}
else if (isalpha(*s))
{
directive = s;
while(isalpha(*s))
s++;
while(isspace(*s))
*(s++) = '\0';
if (*s != '=')
{
fprintf(stderr, "*** expected '='\n");
goto error;
}
*(s++) = '\0';
while(isspace(*s))
s++;
directive_value = s;
if (!mame_stricmp(directive, "imagefile"))
{
/* imagefile directive */
if (img)
imgtool_image_close(img);
strncpyz(filename_base, directive_value, filename_len);
err = imgtool_image_open(module, filename, OSD_FOPEN_READ, &img);
if (err)
goto error;
fprintf(stdout, "%s\n", filename);
}
else if (!mame_stricmp(directive, "files"))
{
/* files directive */
if (!img)
goto needimgmodule;
err = imgtool_directory_open(img, &imgenum);
if (err)
goto error;
memset(&imgdirent, 0, sizeof(imgdirent));
imgdirent.fname = buffer2;
imgdirent.fname_len = sizeof(buffer2);
while(((err = imgtool_directory_get_next(imgenum, &imgdirent)) == 0) && imgdirent.fname[0])
{
i = strlen(buffer2);
buffer2[i++] = ',';
imgdirent.fname = &buffer2[i];
imgdirent.fname_len = sizeof(buffer2) - i;
}
imgtool_directory_close(imgenum);
if (err)
goto error;
i = strlen(buffer2);
if (i > 0)
buffer2[i-1] = '\0';
if (strcmp(directive_value, buffer2))
{
fprintf(stderr, "*** expected files '%s', but instead got '%s'", directive_value, buffer2);
goto error;
}
}
else
{
fprintf(stderr, "*** unrecognized directive '%s'\n", directive);
goto done;
}
}
}
err = 0;
goto done;
needimgmodule:
fprintf(stderr, "*** need [format] declaration before any directives\n");
goto error;
syntaxerror:
fprintf(stderr, "*** syntax error: %s\n", buffer);
goto error;
error:
if (err && (err != -1))
reporterror(err, c, module ? module->name : NULL, filename, NULL, NULL, NULL);
done:
if (inifile)
fclose(inifile);
if (img)
imgtool_image_close(img);
return err;
}