struct string *make_filename(const char *fname)
{
if (strcmp(fname, last_c_filename))
{
free(last_c_filename);
last_c_filename = xstrdup(fname);
last_filename = make_readonly(alloc_string(fname));
}
return last_filename;
}
LOCAL void
out_close(ag_bool purge)
{
if ((pCurFp->flags & FPF_NOCHMOD) == 0)
make_readonly(fileno(pCurFp->pFile));
if (OPT_VALUE_TRACE > TRACE_DEBUG_MESSAGE)
fprintf(pfTrace, OUT_CLOSE_TRACE_WRAP, __func__, pCurFp->pzOutName);
fclose(pCurFp->pFile);
/*
* Only stdout and /dev/null are marked, "NOUNLINK"
*/
if ((pCurFp->flags & FPF_NOUNLINK) == 0) {
/*
* IF we are told to purge the file OR the file is an AutoGen temp
* file, then get rid of the output.
*/
if (purge || ((pCurFp->flags & FPF_UNLINK) != 0))
unlink(pCurFp->pzOutName);
else {
struct utimbuf tbuf;
tbuf.actime = time(NULL);
tbuf.modtime = outTime;
/*
* The putative start time is one second earlier than the
* earliest output file time, regardless of when that is.
*/
if (outTime <= startTime)
startTime = outTime - 1;
utime(pCurFp->pzOutName, &tbuf);
}
}
/*
* Do not deallocate statically allocated names
*/
if ((pCurFp->flags & FPF_STATIC_NM) == 0)
AGFREE((void*)pCurFp->pzOutName);
/*
* Do not deallocate the root entry. It is not allocated!!
*/
if ((pCurFp->flags & FPF_FREE) != 0) {
tFpStack* p = pCurFp;
pCurFp = p->pPrev;
AGFREE((void*)p);
}
}
int harddisk_image_device::internal_load_hd(const char *metadata)
{
chd_error err = (chd_error)0;
int is_writeable;
/* open the CHD file */
do
{
is_writeable = !is_readonly();
m_chd = NULL;
err = chd_open_file(image_core_file(), is_writeable ? CHD_OPEN_READWRITE : CHD_OPEN_READ, NULL, &m_chd);
/* special case; if we get CHDERR_FILE_NOT_WRITEABLE, make the
* image read only and repeat */
if (err == CHDERR_FILE_NOT_WRITEABLE)
make_readonly();
}
while(!m_chd && is_writeable && (err == CHDERR_FILE_NOT_WRITEABLE));
if (!m_chd)
goto done;
/* if we created the image and hence, have metadata to set, set the metadata */
if (metadata)
{
err = chd_set_metadata(m_chd, HARD_DISK_METADATA_TAG, 0, metadata, strlen(metadata) + 1, 0);
if (err != CHDERR_NONE)
goto done;
}
/* open the hard disk file */
m_hard_disk_handle = hard_disk_open(m_chd);
if (!m_hard_disk_handle)
goto done;
done:
if (err)
{
/* if we had an error, close out the CHD */
if (m_chd != NULL)
{
chd_close(m_chd);
m_chd = NULL;
}
seterror(IMAGE_ERROR_UNSPECIFIED, chd_get_error_string(err));
}
return err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
bool device_image_interface::load_internal(const char *path, bool is_create, int create_format, option_resolution *create_args, bool just_load)
{
UINT32 open_plan[4];
int i;
bool softload = FALSE;
m_from_swlist = FALSE;
// if the path contains no period, we are using softlists, so we won't create an image
astring pathstr(path);
bool filename_has_period = (pathstr.rchr(0, '.') != -1) ? TRUE : FALSE;
/* first unload the image */
unload();
/* clear any possible error messages */
clear_error();
/* we are now loading */
m_is_loading = TRUE;
/* record the filename */
m_err = set_image_filename(path);
if (m_err)
goto done;
if (core_opens_image_file())
{
/* Check if there's a software list defined for this device and use that if we're not creating an image */
if (!filename_has_period && !just_load)
{
softload = load_software_part(path, m_software_part_ptr);
if (softload)
{
m_software_info_ptr = &m_software_part_ptr->info();
m_software_list_name.cpy(m_software_info_ptr->list().list_name());
m_full_software_name.cpy(m_software_part_ptr->info().shortname());
// if we had launched from softlist with a specified part, e.g. "shortname:part"
// we would have recorded the wrong name, so record it again based on software_info
if (m_software_info_ptr && m_full_software_name)
m_err = set_image_filename(m_full_software_name);
// check if image should be read-only
const char *read_only = get_feature("read_only");
if (read_only && !strcmp(read_only, "true")) {
make_readonly();
}
m_from_swlist = TRUE;
}
}
if (is_create || filename_has_period)
{
/* determine open plan */
determine_open_plan(is_create, open_plan);
/* attempt to open the file in various ways */
for (i = 0; !m_file && open_plan[i]; i++)
{
/* open the file */
m_err = load_image_by_path(open_plan[i], path);
if (m_err && (m_err != IMAGE_ERROR_FILENOTFOUND))
goto done;
}
}
/* Copy some image information when we have been loaded through a software list */
if ( m_software_info_ptr )
{
// sanitize
if (m_software_info_ptr->longname() == NULL || m_software_info_ptr->publisher() == NULL || m_software_info_ptr->year() == NULL)
fatalerror("Each entry in an XML list must have all of the following fields: description, publisher, year!\n");
// store
m_longname = m_software_info_ptr->longname();
m_manufacturer = m_software_info_ptr->publisher();
m_year = m_software_info_ptr->year();
//m_playable = m_software_info_ptr->supported();
}
/* did we fail to find the file? */
if (!is_loaded() && !softload)
{
m_err = IMAGE_ERROR_FILENOTFOUND;
goto done;
}
}
/* call device load or create */
m_create_format = create_format;
m_create_args = create_args;
if (m_init_phase==FALSE) {
m_err = (image_error_t)finish_load();
if (m_err)
goto done;
}
/* success! */
done:
if (just_load) {
if(m_err) clear();
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
if (m_err!=0) {
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
popmessage("Error: Unable to %s image '%s': %s", is_create ? "create" : "load", path, error());
else
osd_printf_error("Error: Unable to %s image '%s': %s\n", is_create ? "create" : "load", path, error());
}
clear();
}
else {
/* do we need to reset the CPU? only schedule it if load/create is successful */
if (device().machine().time() > attotime::zero && is_reset_on_load())
device().machine().schedule_hard_reset();
else
{
if (!m_init_phase)
{
if (device().machine().phase() == MACHINE_PHASE_RUNNING)
popmessage("Image '%s' was successfully %s.", path, is_create ? "created" : "loaded");
else
osd_printf_info("Image '%s' was successfully %s.\n", path, is_create ? "created" : "loaded");
}
}
}
return m_err ? IMAGE_INIT_FAIL : IMAGE_INIT_PASS;
}
bool cassette_image_device::call_load()
{
casserr_t err;
int cassette_flags;
const char *extension;
int is_writable;
device_image_interface *image = nullptr;
interface(image);
if ((has_been_created()) || (length() == 0))
{
/* creating an image */
err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette);
if (err)
goto error;
}
else
{
/* opening an image */
do
{
is_writable = !is_readonly();
cassette_flags = is_writable ? (CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT) : CASSETTE_FLAG_READONLY;
std::string fname;
if (software_entry()==nullptr) {
extension = filetype();
} else {
fname = m_mame_file->filename();
int loc = fname.find_last_of('.');
if (loc!=-1) {
extension = fname.substr(loc + 1,fname.length()-loc).c_str();
} else {
extension = "";
}
}
err = cassette_open_choices((void *)image, &image_ioprocs, extension, m_formats, cassette_flags, &m_cassette);
/* this is kind of a hack */
if (err && is_writable)
make_readonly();
}
while(err && is_writable);
if (err)
goto error;
}
/* set to default state, but only change the UI state */
change_state(m_default_state, CASSETTE_MASK_UISTATE);
/* reset the position */
m_position = 0.0;
m_position_time = device().machine().time().as_double();
/* default channel to 0, speed multiplier to 1 */
m_channel = 0;
m_speed = 1;
m_direction = 1;
return IMAGE_INIT_PASS;
error:
image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;
switch(err)
{
case CASSETTE_ERROR_INTERNAL:
imgerr = IMAGE_ERROR_INTERNAL;
break;
case CASSETTE_ERROR_UNSUPPORTED:
imgerr = IMAGE_ERROR_UNSUPPORTED;
break;
case CASSETTE_ERROR_OUTOFMEMORY:
imgerr = IMAGE_ERROR_OUTOFMEMORY;
break;
case CASSETTE_ERROR_INVALIDIMAGE:
imgerr = IMAGE_ERROR_INVALIDIMAGE;
break;
default:
imgerr = IMAGE_ERROR_UNSPECIFIED;
break;
}
image->seterror(imgerr, "" );
return IMAGE_INIT_FAIL;
}
static struct icode *generate_function(function f, bool toplevel, fncode fn)
{
/* make help string; must be allocated before code (immutability
restriction) */
struct string *help = NULL;
if (f->help.len)
help = make_readonly(alloc_string_length(f->help.str, f->help.len));
struct string *varname = NULL, *filename = NULL, *nicename = NULL;
struct vector *arg_types = NULL;
GCPRO5(help, varname, filename, nicename, arg_types);
/* Make variable name (if present) */
if (f->varname)
varname = make_readonly(alloc_string(f->varname));
else
varname = NULL;
/* Make filename string */
filename = make_filename(f->filename);
nicename = make_filename(f->nicename);
arg_types = make_arg_types(f);
fncode newfn = new_fncode(toplevel);
set_lineno(f->lineno, newfn);
if (f->varargs)
/* varargs makes a vector from the first nargs entries of the stack and
stores it in local value 0 */
ins0(op_varargs, newfn);
else
{
/* First, generate code to check the argument types & count */
/* argcheck copies the arguments into the local variables, assuming that
the last argument (on top of the stack) is local value 0, the next to
last local value 1, and so on.
It then discards all the parameters */
int nargs = 0;
for (vlist argument = f->args; argument; argument = argument->next)
nargs++;
ins1(op_argcheck, nargs, newfn);
nargs = 0;
for (vlist argument = f->args; argument; argument = argument->next)
{
generate_typeset_check(argument->typeset, nargs, newfn);
nargs++;
}
ins1(op_pop_n, nargs, newfn);
}
/* Generate code of function */
env_push(f->args, newfn);
start_block("function", newfn);
generate_component(f->value, newfn);
end_block(newfn);
generate_typeset_check(f->typeset, 0, newfn);
ins0(op_return, newfn);
peephole(newfn);
struct icode *c = generate_fncode(
newfn, help, varname, filename, nicename, f->lineno, arg_types,
f->typeset, compile_level);
varlist closure = env_pop(&c->nb_locals);
UNGCPRO();
/* Generate code for creating closure */
/* Count length of closure */
int clen = 0;
for (varlist cvar = closure; cvar; cvar = cvar->next) clen++;
/* Generate closure */
ins1(op_closure, clen, fn);
/* Add variables to it */
for (varlist cvar = closure; cvar; cvar = cvar->next)
ins1(op_closure_var + cvar->vclass, cvar->offset, fn);
delete_fncode(newfn);
return c;
}
int main(int argc, char *argv[])
{
if(argc<2)
{
std::cout << "Not enough parameters" << std::endl;
return 1;
}
std::string cmd;
int mode = 0;
if((std::string)argv[1]!="test")
{
if(argc<3)
{
std::cout << "Not enough parameters" << std::endl;
return 1;
}
cmd=argv[2];
mode=atoi(argv[1]);
}
else
{
cmd=argv[1];
}
std::string backupfolder=getBackupfolderPath(mode);
if(backupfolder.empty())
{
if(mode==mode_btrfs)
{
std::cout << "Backupfolder not set" << std::endl;
}
else if(mode==mode_zfs)
{
std::cout << "ZFS image dataset not set" << std::endl;
}
else if(mode==mode_zfs_file)
{
std::cout << "ZFS file dataset not set" << std::endl;
}
else
{
std::cout << "Unknown mode: " << mode << std::endl;
}
return 1;
}
if(cmd!="test" && mode==mode_zfs_file)
{
mode=mode_zfs;
}
#ifndef _WIN32
if(seteuid(0)!=0)
{
std::cout << "Cannot become root user" << std::endl;
return 1;
}
#endif
if(cmd=="create")
{
if(argc<5)
{
std::cout << "Not enough parameters for create" << std::endl;
return 1;
}
std::string clientname=handleFilename(argv[3]);
std::string name=handleFilename(argv[4]);
std::string subvolume_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+name;
return create_subvolume(mode, subvolume_folder)?0:1;
}
else if(cmd=="mountpoint")
{
if(argc<5)
{
std::cout << "Not enough parameters for mountpoint" << std::endl;
return 1;
}
std::string clientname=handleFilename(argv[3]);
std::string name=handleFilename(argv[4]);
std::string subvolume_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+name;
return get_mountpoint(mode, subvolume_folder)?0:1;
}
else if(cmd=="snapshot")
{
if(argc<6)
{
std::cout << "Not enough parameters for snapshot" << std::endl;
return 1;
}
std::string clientname=handleFilename(argv[3]);
std::string src_name=handleFilename(argv[4]);
std::string dst_name=handleFilename(argv[5]);
std::string subvolume_src_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+src_name;
std::string subvolume_dst_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+dst_name;
return create_snapshot(mode, subvolume_src_folder, subvolume_dst_folder)?0:1;
}
else if(cmd=="remove")
{
if(argc<5)
{
std::cout << "Not enough parameters for remove" << std::endl;
return 1;
}
std::string clientname=handleFilename(argv[3]);
std::string name=handleFilename(argv[4]);
std::string subvolume_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+name;
return remove_subvolume(mode, subvolume_folder)?0:1;
}
else if(cmd=="test")
{
std::cout << "Testing for btrfs..." << std::endl;
std::string clientdir=backupfolder+os_file_sep()+"testA54hj5luZtlorr494";
bool create_dir_rc=os_create_dir(clientdir);
if(!create_dir_rc)
{
remove_subvolume(mode_zfs, clientdir, true);
remove_subvolume(mode_btrfs, clientdir+os_file_sep()+"A", true);
remove_subvolume(mode_btrfs, clientdir+os_file_sep()+"B", true);
os_remove_dir(clientdir);
}
create_dir_rc = create_dir_rc || os_create_dir(clientdir);
if(create_dir_rc)
{
if(!create_subvolume(mode_btrfs, clientdir+os_file_sep()+"A") )
{
std::cout << "TEST FAILED: Creating test btrfs subvolume failed" << std::endl;
os_remove_dir(clientdir);
return zfs_test();
}
bool suc=true;
if(!create_snapshot(mode_btrfs, clientdir+os_file_sep()+"A", clientdir+os_file_sep()+"B") )
{
std::cout << "TEST FAILED: Creating test snapshot failed" << std::endl;
suc=false;
}
if(suc)
{
writestring("test", clientdir+os_file_sep()+"A"+os_file_sep()+"test");
if(!os_create_hardlink(clientdir+os_file_sep()+"B"+os_file_sep()+"test", clientdir+os_file_sep()+"A"+os_file_sep()+"test", true, NULL))
{
std::cout << "TEST FAILED: Creating cross sub-volume reflink failed. Need Linux kernel >= 3.6." << std::endl;
suc=false;
}
else
{
if(getFile(clientdir+os_file_sep()+"B"+os_file_sep()+"test")!="test")
{
std::cout << "TEST FAILED: Cannot read reflinked file" << std::endl;
suc=false;
}
}
}
if(!remove_subvolume(mode_btrfs, clientdir+os_file_sep()+"A") )
{
std::cout << "TEST FAILED: Removing subvolume A failed" << std::endl;
suc=false;
}
if(!remove_subvolume(mode_btrfs, clientdir+os_file_sep()+"B") )
{
std::cout << "TEST FAILED: Removing subvolume B failed" << std::endl;
suc=false;
}
if(!os_remove_dir(clientdir))
{
std::cout << "TEST FAILED: Removing test clientdir failed" << std::endl;
return 1;
}
if(!suc)
{
return 1;
}
}
else
{
std::cout << "TEST FAILED: Creating test clientdir \"" << clientdir << "\" failed" << std::endl;
return zfs_test();
}
std::cout << "BTRFS TEST OK" << std::endl;
return 10 + mode_btrfs;
}
else if(cmd=="issubvolume")
{
if(argc<5)
{
std::cout << "Not enough parameters for issubvolume" << std::endl;
return 1;
}
std::string clientname=handleFilename(argv[3]);
std::string name=handleFilename(argv[4]);
std::string subvolume_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+name;
return is_subvolume(mode, subvolume_folder)?0:1;
}
else if(cmd=="makereadonly")
{
if(argc<5)
{
std::cout << "Not enough parameters for makereadonly" << std::endl;
return 1;
}
std::string clientname=handleFilename(argv[3]);
std::string name=handleFilename(argv[4]);
std::string subvolume_folder=backupfolder+os_file_sep()+clientname+os_file_sep()+name;
return make_readonly(mode, subvolume_folder)?0:1;
}
else
{
std::cout << "Command not found" << std::endl;
return 1;
}
}
image_init_result cassette_image_device::internal_load(bool is_create)
{
cassette_image::error err;
device_image_interface *image = nullptr;
interface(image);
if (is_create)
{
// creating an image
err = cassette_create((void *)image, &image_ioprocs, &wavfile_format, m_create_opts, CASSETTE_FLAG_READWRITE|CASSETTE_FLAG_SAVEONEXIT, &m_cassette);
if (err != cassette_image::error::SUCCESS)
goto error;
}
else
{
// opening an image
bool retry;
do
{
// we probably don't want to retry...
retry = false;
// try opening the cassette
int cassette_flags = is_readonly()
? CASSETTE_FLAG_READONLY
: (CASSETTE_FLAG_READWRITE | CASSETTE_FLAG_SAVEONEXIT);
err = cassette_open_choices((void *)image, &image_ioprocs, filetype(), m_formats, cassette_flags, &m_cassette);
// special case - if we failed due to readwrite not being supported, make the image be read only and retry
if (err == cassette_image::error::READ_WRITE_UNSUPPORTED)
{
make_readonly();
retry = true;
}
}
while(retry);
if (err != cassette_image::error::SUCCESS)
goto error;
}
/* set to default state, but only change the UI state */
change_state(m_default_state, CASSETTE_MASK_UISTATE);
/* reset the position */
m_position = 0.0;
m_position_time = device().machine().time().as_double();
/* default channel to 0, speed multiplier to 1 */
m_channel = 0;
m_speed = 1;
m_direction = 1;
return image_init_result::PASS;
error:
image_error_t imgerr = IMAGE_ERROR_UNSPECIFIED;
switch(err)
{
case cassette_image::error::INTERNAL:
imgerr = IMAGE_ERROR_INTERNAL;
break;
case cassette_image::error::UNSUPPORTED:
imgerr = IMAGE_ERROR_UNSUPPORTED;
break;
case cassette_image::error::OUT_OF_MEMORY:
imgerr = IMAGE_ERROR_OUTOFMEMORY;
break;
case cassette_image::error::INVALID_IMAGE:
imgerr = IMAGE_ERROR_INVALIDIMAGE;
break;
default:
imgerr = IMAGE_ERROR_UNSPECIFIED;
break;
}
image->seterror(imgerr, "" );
return image_init_result::FAIL;
}