static void event_playback_attach_image(void *data, unsigned int size)
{
unsigned int unit, read_only;
char *orig_filename, *filename = NULL;
size_t file_len;
unit = (unsigned int)((char*)data)[0];
read_only = (unsigned int)((char*)data)[1];
orig_filename = &((char*)data)[2];
file_len = size - strlen(orig_filename) - 3;
if (file_len > 0) {
FILE *fd;
fd = archdep_mkstemp_fd(&filename, MODE_WRITE);
if (fd == NULL) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_CREATE_IMAGE), filename);
#else
ui_error(_("Cannot create image file!"));
#endif
goto error;
}
if (fwrite((char*)data + strlen(orig_filename) + 3, file_len, 1, fd) != 1) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_WRITE_IMAGE_FILE_S), filename);
#else
ui_error(_("Cannot write image file %s"), filename);
#endif
goto error;
}
fclose(fd);
event_image_append(orig_filename, &filename, 1);
} else {
if (event_image_append(orig_filename, &filename, 0) != 0) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_FIND_MAPPED_NAME_S), orig_filename);
#else
ui_error(_("Cannot find mapped name for %s"), orig_filename);
#endif
return;
}
}
/* now filename holds the name to attach */
/* FIXME: read_only isn't handled for tape */
if (unit == 1) {
tape_image_event_playback(unit, filename);
} else {
resources_set_int_sprintf("AttachDevice%dReadonly", read_only, unit);
file_system_event_playback(unit, filename);
}
error:
lib_free(filename);
}
static int tape_snapshot_read_tapimage_module(snapshot_t *s)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
char *filename = NULL;
FILE *ftap;
BYTE *buffer;
long tap_size;
m = snapshot_module_open(s, "TAPIMAGE",
&major_version, &minor_version);
if (m == NULL)
return 0;
if (major_version > TAPIMAGE_SNAP_MAJOR
|| minor_version > TAPIMAGE_SNAP_MINOR) {
log_error(tape_snapshot_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
TAPIMAGE_SNAP_MAJOR, TAPIMAGE_SNAP_MINOR);
}
/* create temporary file */
/* FIXME: Were is this file deleted? */
ftap = archdep_mkstemp_fd(&filename, MODE_WRITE);
if (ftap == NULL) {
log_error(tape_snapshot_log, "Could not create temporary file!");
snapshot_module_close(m);
goto fail;
}
SMR_DW_UL(m, (unsigned long *)&tap_size);
buffer = lib_malloc(tap_size);
SMR_BA(m, buffer, tap_size);
if (fwrite(buffer, tap_size, 1, ftap) != 1) {
log_error(tape_snapshot_log, "Could not create temporary file");
log_error(tape_snapshot_log, "filename=%s", filename);
snapshot_module_close(m);
fclose(ftap);
goto fail;
}
lib_free(buffer);
fclose(ftap);
tape_image_attach(1, filename);
lib_free(filename);
snapshot_module_close(m);
return 0;
fail:
lib_free(filename);
return -1;
}
int network_connect_client(void)
{
struct sockaddr_in server_addr;
#ifdef HAVE_IPV6
struct sockaddr_in6 server_addr6;
#ifndef HAVE_GETHOSTBYNAME2
int err6;
#endif
#endif
struct hostent *server_hostent;
FILE *f;
BYTE *buf;
BYTE recv_buf4[4];
size_t buf_size;
int return_value;
if (network_init() < 0)
return -1;
if (network_mode != NETWORK_IDLE)
return -1;
vsync_suspend_speed_eval();
snapshotfilename = NULL;
f = archdep_mkstemp_fd(&snapshotfilename, MODE_WRITE);
if (f == NULL) {
#ifdef HAS_TRANSLATION
ui_error(translate_text(IDGS_CANNOT_CREATE_SNAPSHOT_S_SELECT));
#else
ui_error(_("Cannot create snapshot file. Select different history directory!"));
#endif
return -1;
}
#ifdef HAVE_IPV6
if (netplay_ipv6)
#ifdef HAVE_GETHOSTBYNAME2
server_hostent = gethostbyname2(server_name, PF_INET6);
#else
server_hostent = getipnodebyname(server_name, PF_INET6, AI_DEFAULT, &err6);
#endif
else
static int drive_snapshot_read_image_module(snapshot_t *s, unsigned int dnr)
{
BYTE major_version, minor_version;
snapshot_module_t *m;
char snap_module_name[10];
WORD word;
char *filename = NULL;
char *request_str;
int len = 0;
FILE *fp;
BYTE sector_data[0x100];
disk_addr_t dadr;
int rc;
drive_t *drive;
drive = drive_context[dnr]->drive;
sprintf(snap_module_name, "NOIMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m != NULL) {
file_system_detach_disk(dnr + 8);
snapshot_module_close(m);
return 0;
}
sprintf(snap_module_name, "IMAGE%i", dnr);
m = snapshot_module_open(s, snap_module_name,
&major_version, &minor_version);
if (m == NULL) {
return 0;
}
if (major_version > IMAGE_SNAP_MAJOR || minor_version > IMAGE_SNAP_MINOR) {
log_error(drive_snapshot_log,
"Snapshot module version (%d.%d) newer than %d.%d.",
major_version, minor_version,
IMAGE_SNAP_MAJOR, IMAGE_SNAP_MINOR);
}
if (SMR_W(m, &word) < 0) {
snapshot_module_close(m);
return -1;
}
switch (word) {
case 1581:
len = D81_FILE_SIZE;
break;
case 8050:
len = D80_FILE_SIZE;
break;
case 8250:
len = D82_FILE_SIZE;
break;
default:
log_error(drive_snapshot_log,
"Snapshot of disk image unknown (type %d)",
(int)word);
snapshot_module_close(m);
return -1;
}
/* create temporary file of the right size */
fp = archdep_mkstemp_fd(&filename, MODE_WRITE);
if (fp == NULL) {
log_error(drive_snapshot_log, "Could not create temporary file!");
snapshot_module_close(m);
return -1;
}
/* blow up the file to needed size */
if (fseek(fp, len - 1, SEEK_SET) < 0
|| (fputc(0, fp) == EOF)) {
log_error(drive_snapshot_log, "Could not create large temporary file");
fclose(fp);
lib_free(filename);
snapshot_module_close(m);
return -1;
}
fclose(fp);
lib_free(filename);
if (file_system_attach_disk(dnr + 8, filename) < 0) {
log_error(drive_snapshot_log, "Invalid Disk Image");
lib_free(filename);
snapshot_module_close(m);
return -1;
}
request_str = lib_msprintf("Disk image unit #%d imported from snapshot",
dnr + 8);
zfile_close_action(filename, ZFILE_REQUEST, request_str);
lib_free(request_str);
/* we use the return code to step through the tracks. So we do not
need any geometry info. */
SMR_BA(m, sector_data, 0x100);
for (dadr.track = 1;; dadr.track++) {
rc = 0;
for (dadr.sector = 0;; dadr.sector++) {
rc = disk_image_write_sector(drive->image, sector_data, &dadr);
if (rc == 0) {
SMR_BA(m, sector_data, 0x100);
} else {
break;
}
}
if (dadr.sector == 0) {
break;
}
}
vdrive_bam_reread_bam(dnr + 8);
snapshot_module_close(m);
m = NULL;
return 0;
}
/* If `name' has a gzip-like extension, try to uncompress it into a temporary
file using gzip or zlib if available. If this succeeds, return the name
of the temporary file; return NULL otherwise. */
static char *try_uncompress_with_gzip(const char *name)
{
#ifdef HAVE_ZLIB
FILE *fddest;
gzFile fdsrc;
char *tmp_name = NULL;
int len;
if (!archdep_file_is_gzip(name)) {
return NULL;
}
fddest = archdep_mkstemp_fd(&tmp_name, MODE_WRITE);
if (fddest == NULL) {
return NULL;
}
fdsrc = gzopen(name, MODE_READ);
if (fdsrc == NULL) {
fclose(fddest);
ioutil_remove(tmp_name);
lib_free(tmp_name);
return NULL;
}
do {
char buf[256];
len = gzread(fdsrc, (void *)buf, 256);
if (len > 0) {
if (fwrite((void *)buf, 1, (size_t)len, fddest) < len) {
gzclose(fdsrc);
fclose(fddest);
ioutil_remove(tmp_name);
lib_free(tmp_name);
return NULL;
}
}
} while (len > 0);
gzclose(fdsrc);
fclose(fddest);
return tmp_name;
#else
char *tmp_name = NULL;
int exit_status;
char *argv[4];
if (!archdep_file_is_gzip(name)) {
return NULL;
}
/* `exec*()' does not want these to be constant... */
argv[0] = lib_stralloc("gzip");
argv[1] = lib_stralloc("-cd");
argv[2] = archdep_filename_parameter(name);
argv[3] = NULL;
ZDEBUG(("try_uncompress_with_gzip: spawning gzip -cd %s", name));
exit_status = archdep_spawn("gzip", argv, &tmp_name, NULL);
lib_free(argv[0]);
lib_free(argv[1]);
lib_free(argv[2]);
if (exit_status == 0) {
ZDEBUG(("try_uncompress_with_gzip: OK"));
return tmp_name;
} else {
ZDEBUG(("try_uncompress_with_gzip: failed"));
ioutil_remove(tmp_name);
lib_free(tmp_name);
return NULL;
}
#endif
}
int network_connect_client(void)
{
vice_network_socket_address_t * server_addr;
FILE *f;
BYTE *buf;
BYTE recv_buf4[4];
size_t buf_size;
if (network_mode != NETWORK_IDLE)
return -1;
vsync_suspend_speed_eval();
snapshotfilename = NULL;
f = archdep_mkstemp_fd(&snapshotfilename, MODE_WRITE);
if (f == NULL) {
ui_error(translate_text(IDGS_CANNOT_CREATE_SNAPSHOT_S_SELECT));
return -1;
}
server_addr = vice_network_address_generate(server_name, server_port);
if (server_addr == NULL) {
ui_error(translate_text(IDGS_CANNOT_RESOLVE_S), server_name);
return -1;
}
network_socket = vice_network_client(server_addr);
vice_network_address_close(server_addr);
server_addr = NULL;
if ( ! network_socket ) {
ui_error(translate_text(IDGS_CANNOT_CONNECT_TO_S),
server_name, server_port);
lib_free(snapshotfilename);
return -1;
}
ui_display_statustext(translate_text(IDGS_RECEIVING_SNAPSHOT_SERVER), 0);
if (network_recv_buffer(network_socket, recv_buf4, 4) < 0) {
lib_free(snapshotfilename);
vice_network_socket_close(network_socket);
return -1;
}
buf_size = (size_t)util_le_buf4_to_int(recv_buf4);
buf = lib_malloc(buf_size);
if (network_recv_buffer(network_socket, buf, (int)buf_size) < 0) {
lib_free(snapshotfilename);
vice_network_socket_close(network_socket);
return -1;
}
if (fwrite(buf, 1, buf_size, f) <= 0) {
log_debug("network_connect_client write failed.");
}
fclose(f);
lib_free(buf);
interrupt_maincpu_trigger_trap(network_client_connect_trap, (void *)0);
vsync_suspend_speed_eval();
return 0;
}
