path: root/trs_imp_exp.c

/* Copyright (c) 1996, Timothy Mann */

/* This software may be copied, modified, and used for any purpose
 * without fee, provided that (1) the above copyright notice is
 * retained, and (2) modified versions are clearly marked as having
 * been modified, with the modifier's name and the date included.  */

/*
 * trs_imp_exp.c
 *
 * Features to make transferring files into and out of the emulator
 *  easier.  
 */

#include <stdio.h>
#include <errno.h>
#include <signal.h>
#include <string.h>
#include <time.h>
#include <dirent.h>
#include <unistd.h>
#include <stdlib.h>
#include <fcntl.h>
#include "trs_imp_exp.h"
#include "z80.h"
#include "trs.h"
#include "trs_disk.h"

/*
   If the following option is set, potentially dangerous emulator traps
   will be blocked, including file writes to the host filesystem and shell
   command execution.
 */
int trs_emtsafe = 0;

/* New emulator traps */

#define MAX_OPENDIR 32
DIR *dir[MAX_OPENDIR] = { NULL, };

typedef struct {
  int fd;
  int inuse;
} OpenDisk;
#define MAX_OPENDISK 32
OpenDisk od[MAX_OPENDISK];

void do_emt_system()
{
  int res;
  if (trs_emtsafe) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }
  res = system((char *)mem_pointer(reg_HL, 0));
  if (res == -1) {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  } else {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  }
  reg_BC = res;
}

void do_emt_mouse()
{
  int x, y;
  unsigned int buttons, sens;
  switch (reg_B) {
  case 1:
    trs_get_mouse_pos(&x, &y, &buttons);
    reg_HL = x;
    reg_DE = y;
    reg_A = buttons;
    if (reg_A) {
      reg_F &= ~ZERO_MASK;
    } else {
      reg_F |= ZERO_MASK;
    }
    break;
  case 2:
    trs_set_mouse_pos(reg_HL, reg_DE);
    reg_A = 0;
    reg_F |= ZERO_MASK;
    break;
  case 3:
    trs_get_mouse_max(&x, &y, &sens);
    reg_HL = x;
    reg_DE = y;
    reg_A = sens;
    if (reg_A) {
      reg_F &= ~ZERO_MASK;
    } else {
      reg_F |= ZERO_MASK;
    }
    break;
  case 4:
    trs_set_mouse_max(reg_HL, reg_DE, reg_C);
    reg_A = 0;
    reg_F |= ZERO_MASK;
    break;
  case 5:
    reg_A = trs_get_mouse_type();
    if (reg_A) {
      reg_F &= ~ZERO_MASK;
    } else {
      reg_F |= ZERO_MASK;
    }
    break;
  default:
    error("undefined emt_mouse function code");
    break;
  }
}

void do_emt_getddir()
{
  if (reg_HL + reg_BC > 0x10000 ||
      reg_HL + strlen(trs_disk_dir) + 1 > reg_HL + reg_BC) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  strcpy((char *)mem_pointer(reg_HL, 1), trs_disk_dir);
  reg_A = 0;
  reg_F |= ZERO_MASK;
  reg_BC = strlen(trs_disk_dir);
}

void do_emt_setddir()
{
  if (trs_emtsafe) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }
  trs_disk_dir = strdup((char *)mem_pointer(reg_HL, 0));
  if (trs_disk_dir[0] == '~' &&
      (trs_disk_dir[1] == '/' || trs_disk_dir[1] == '\0')) {
    char* home = getenv("HOME");
    if (home) {
      char *p = (char*)malloc(strlen(home) + strlen(trs_disk_dir) + 2);
      sprintf(p, "%s/%s", home, trs_disk_dir+1);
      free(trs_disk_dir);
      trs_disk_dir = p;
    }
  }
  reg_A = 0;
  reg_F |= ZERO_MASK;
}

void do_emt_open()
{
  int fd, oflag, eoflag;
  eoflag = reg_BC;
  switch (eoflag & EO_ACCMODE) {
  case EO_RDONLY:
  default:
    oflag = O_RDONLY;
    break;
  case EO_WRONLY:
    oflag = O_WRONLY;
    break;
  case EO_RDWR:
    oflag = O_RDWR;
    break;
  }
  if (eoflag & EO_CREAT)  oflag |= O_CREAT;
  if (eoflag & EO_EXCL)   oflag |= O_EXCL;
  if (eoflag & EO_TRUNC)  oflag |= O_TRUNC;
  if (eoflag & EO_APPEND) oflag |= O_APPEND;

  if (trs_emtsafe && oflag != O_RDONLY) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }
  fd = open((char *)mem_pointer(reg_HL, 0), oflag, reg_DE);
  if (fd >= 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
  reg_DE = fd;
}

void do_emt_close()
{
  int res;
  res = close(reg_DE);
  if (res >= 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
}

void do_emt_read()
{
  int size;
  if (reg_HL + reg_BC > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  size = read(reg_DE, mem_pointer(reg_HL, 1), reg_BC);
  if (size >= 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
  reg_BC = size;
}


void do_emt_write()
{
  int size;
  if (trs_emtsafe) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }
  if (reg_HL + reg_BC > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  size = write(reg_DE, mem_pointer(reg_HL, 0), reg_BC);
  if (size >= 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
  reg_BC = size;
}

void do_emt_lseek()
{
  int i;
  off_t offset;
  if (reg_HL + 8 > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    return;
  }
  offset = 0;
  for (i=0; i<8; i++) {
    offset = offset + (mem_read(reg_HL + i) << i*8);
  }
  offset = lseek(reg_DE, offset, reg_BC);
  if (offset != (off_t) -1) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
  for (i=reg_HL; i<8; i++) {
    mem_write(reg_HL + i, offset & 0xff);
    offset >>= 8;
  }
}

void do_emt_strerror()
{
  char *msg;
  int size;
  if (reg_HL + reg_BC > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  errno = 0;
  msg = strerror(reg_A);
  size = strlen(msg);
  if (errno != 0) {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  } else if (reg_BC < size + 2) {
    reg_A = ERANGE;
    reg_F &= ~ZERO_MASK;
    size = reg_BC - 1;
  } else {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  }
  memcpy(mem_pointer(reg_HL, 1), msg, size);
  mem_write(reg_HL + size++, '\r');
  mem_write(reg_HL + size, '\0');
  if (errno == 0) {
    reg_BC = size;
  } else {
    reg_BC = 0xFFFF;
  }
}

void do_emt_time()
{
  time_t now = time(0);
  if (reg_A == 1) {
#if __alpha
    struct tm *loctm = localtime(&now);
    now += loctm->tm_gmtoff;
#else
    struct tm loctm = *(localtime(&now));
    struct tm gmtm = *(gmtime(&now));
    int daydiff = loctm.tm_mday - gmtm.tm_mday;
    now += (loctm.tm_sec - gmtm.tm_sec)
      + (loctm.tm_min - gmtm.tm_min) * 60
      + (loctm.tm_hour - gmtm.tm_hour) * 3600;
    switch (daydiff) {
    case 0:
    case 1:
    case -1:
      now += 24*3600 * daydiff;
      break;
    case 30:
    case 29:
    case 28:
    case 27:
      now -= 24*3600;
      break;
    case -30:
    case -29:
    case -28:
    case -27:
      now += 24*3600;
      break;
    default:
      error("trouble computing local time in emt_time");
    }
#endif
  } else if (reg_A != 0) {
    error("unsupported function code to emt_time");
  }
  reg_BC = (now >> 16) & 0xffff;
  reg_DE = now & 0xffff;
}

void do_emt_opendir()
{
  int i;
  for (i = 0; i < MAX_OPENDIR; i++) {
    if (dir[i] == NULL) break;
  }
  if (i == MAX_OPENDIR) {
    reg_DE = 0xffff;
    reg_A = EMFILE;
    return;
  }
  dir[i] = opendir((char *)mem_pointer(reg_HL, 0));
  if (dir[i] == NULL) {
    reg_DE = 0xffff;
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  } else {
    reg_DE = i;
    reg_A = 0;
    reg_F |= ZERO_MASK;
  }
}

void do_emt_closedir()
{
  int i = reg_DE;
  int ok;
  if (i < 0 || i >= MAX_OPENDIR || dir[i] == NULL) {
    reg_A = EBADF;
    reg_F &= ~ZERO_MASK;
    return;
  }	
  ok = closedir(dir[i]);
  dir[i] = NULL;
  if (ok >= 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
}

void do_emt_readdir()
{
  int size, i = reg_DE;
  struct dirent *result;

  if (i < 0 || i >= MAX_OPENDIR || dir[i] == NULL) {
    reg_A = EBADF;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }	
  if (reg_HL + reg_BC > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  result = readdir(dir[i]);
  if (result == NULL) {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  size = strlen(result->d_name);
  if (size + 1 > reg_BC) {
    reg_A = ERANGE;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  strcpy((char *)mem_pointer(reg_HL, 1), result->d_name);
  reg_A = 0;
  reg_F |= ZERO_MASK;
  reg_BC = size;
}

void do_emt_chdir()
{
  int ok;
  if (trs_emtsafe) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }
  ok = chdir((char *)mem_pointer(reg_HL, 0));
  if (ok < 0) {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  } else {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  }
}

void do_emt_getcwd()
{
  char *result;
  if (reg_HL + reg_BC > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  result = getcwd((char *)mem_pointer(reg_HL, 1), reg_BC);
  if (result == NULL) {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
    reg_BC = 0xFFFF;
    return;
  }
  reg_A = 0;
  reg_F |= ZERO_MASK;
  reg_BC = strlen(result);
}

void do_emt_misc()
{
  switch (reg_A) {
  case 0:
    trs_disk_change_all();
    reg_HL = trs_disk_changecount;
    break;
  case 1:
    trs_exit();
    break;
  case 2:
    trs_debug();
    break;
  case 3:
    trs_reset(0);
    break;
  case 4:
    reg_HL = trs_disk_changecount;
    break;
  case 5:
    reg_HL = trs_model;
    break;
  case 6:
    reg_HL = trs_disk_getsize(reg_BC);
    break;
  case 7:
    trs_disk_setsize(reg_BC, reg_HL);
    break;
  case 8:
    reg_HL = trs_disk_getstep(reg_BC);
    break;
  case 9:
    trs_disk_setstep(reg_BC, reg_HL);
    break;
  case 10:
    reg_HL = grafyx_get_microlabs();
    break;
  case 11:
    grafyx_set_microlabs(reg_HL);
    break;
  case 12:
    reg_HL = z80_state.delay;
    reg_BC = trs_autodelay;
    break;
  case 13:
    z80_state.delay = reg_HL;
    trs_autodelay = reg_BC;
    break;
  case 14:
    reg_HL = stretch_amount;
    break;
  case 15:
    stretch_amount = reg_HL;
    break;
  case 16:
    reg_HL = trs_disk_doubler;
    break;
  case 17:
    trs_disk_doubler = reg_HL;
    break;
  case 18:
    reg_HL = sb_get_volume();
    break;
  case 19:
    sb_set_volume(reg_HL);
    break;
  case 20:
    reg_HL = trs_disk_truedam;
    break;
  case 21:
    trs_disk_truedam = reg_HL;
    break;
  default:
    error("unsupported function code to emt_misc");
    break;
  }
}

void do_emt_ftruncate()
{
  int i, result;
  off_t offset;
  if (trs_emtsafe) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }
  if (reg_HL + 8 > 0x10000) {
    reg_A = EFAULT;
    reg_F &= ~ZERO_MASK;
    return;
  }
  offset = 0;
  for (i=0; i<8; i++) {
    offset = offset + (mem_read(reg_HL + i) << i*8);
  }
  result = ftruncate(reg_DE, offset);
  if (result == 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
}

void do_emt_opendisk()
{
  char *name = (char *)mem_pointer(reg_HL, 0);
  char *qname;
  int i;
  int oflag, eoflag;

  eoflag = reg_BC;
  switch (eoflag & EO_ACCMODE) {
  case EO_RDONLY:
  default:
    oflag = O_RDONLY;
    break;
  case EO_WRONLY:
    oflag = O_WRONLY;
    break;
  case EO_RDWR:
    oflag = O_RDWR;
    break;
  }
  if (eoflag & EO_CREAT)  oflag |= O_CREAT;
  if (eoflag & EO_EXCL)   oflag |= O_EXCL;
  if (eoflag & EO_TRUNC)  oflag |= O_TRUNC;
  if (eoflag & EO_APPEND) oflag |= O_APPEND;

  if (trs_emtsafe && oflag != O_RDONLY) {
    error("potentially dangerous emulator trap blocked");
    reg_A = EACCES;
    reg_F &= ~ZERO_MASK;
    return;
  }

  if (*name == '/' || *trs_disk_dir == '\0') {
    qname = strdup(name);
  } else {
    qname = (char *)malloc(strlen(trs_disk_dir) + 1 + strlen(name) + 1);
    strcpy(qname, trs_disk_dir);
    strcat(qname, "/");
    strcat(qname, name);
  }
  for (i = 0; i < MAX_OPENDISK; i++) {
    if (!od[i].inuse) break;
  }
  if (i == MAX_OPENDISK) {
    reg_DE = 0xffff;
    reg_A = EMFILE;
    reg_F &= ~ZERO_MASK;
    free(qname);
    return;
  }
  od[i].fd = open(qname, oflag, reg_DE);
  free(qname);
  if (od[i].fd >= 0) {
    od[i].inuse = 1;
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
  reg_DE = od[i].fd;
}

void do_emt_closedisk()
{
  int i;
  int res;
  if (reg_DE == 0xffff) {
    for (i = 0; i < MAX_OPENDISK; i++) {
      if (od[i].inuse) {
	close(od[i].fd);
	od[i].inuse = 0;
      }
    }
    reg_A = 0;
    reg_F |= ZERO_MASK;
    return;
  }

  for (i = 0; i < MAX_OPENDISK; i++) {
    if (od[i].inuse && od[i].fd == reg_DE) break;
  }
  if (i == MAX_OPENDISK) {
    reg_A = EBADF;
    reg_F &= ~ZERO_MASK;
    return;
  }
  od[i].inuse = 0;
  res = close(od[i].fd);
  if (res >= 0) {
    reg_A = 0;
    reg_F |= ZERO_MASK;
  } else {
    reg_A = errno;
    reg_F &= ~ZERO_MASK;
  }
}