path: root/tools/fileop.c

#include <ctype.h>
#include <errno.h>
#include <stdlib.h>
#include <stdio.h>
#include <string.h>
#include <unistd.h>
#include <alloca.h>
#include <inttypes.h>
#include <stdbool.h>

#ifndef O_TEXT
# define O_TEXT	0
#endif
#ifndef O_BINARY
# define O_BINARY 0
#endif

const char *file_op_dir;

static ssize_t xwrite(int fd, const void *buf, size_t count)
{
  const char *p = buf;
  ssize_t out = 0;
  ssize_t rv;
  
  while (count) {
    rv = write(fd, p, count);
    if (rv == -1) {
      if (errno == EINTR || errno == EAGAIN)
	continue;
      return out ? out : -1; /* Error */
    } else if (rv == 0) {
      return out; /* EOF */
    }
    
    p += rv;
    out += rv;
    count -= rv;
  }
  
  return out;
}

static enum {
  st_op,
  st_filename,
  st_len,
  st_data
} state = st_op;
static int byte_count = 4;
static unsigned char cmd[4];
static unsigned char *bytep = cmd;
static struct file_data *filemap[65536];

struct file_data {
  FILE *f;
};

static void send_reply(int fd, int status)
{
  unsigned char reply[4];
  
  reply[0] = 0xff;
  reply[1] = cmd[0];
  reply[2] = cmd[1];
  reply[3] = status;

  if (fd >= 0) {
    xwrite(fd, reply, 4);
    fprintf(stderr, "Sending reply: %02X %02X %02X %02X\n",
	    reply[0], reply[1], reply[2], reply[3]);
  }
}

static void do_close(int fd, uint16_t ix)
{
  struct file_data *fm = filemap[ix];

  if (fm) {
    fclose(fm->f);
    free(fm);
    filemap[ix] = NULL;
    send_reply(fd, 0);
  } else {
    send_reply(fd, 128+45);	/* "Fel logiskt filnummer" */
  }
}

static void do_closeall(int fd)
{
  int ix;

  for (ix = 0; ix <= 65535; ix++)
    if (filemap[ix])
      do_close(-1, ix);

  if (cmd[0] == 0xA8)
    send_reply(fd, 0);
}

/* XXX: This assumes Latin-1; Unicode requires more sophistication */
static const char my_tolower[256] =
  "\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"
  "\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"
  " !\"#$%&'()*+,-./0123456789:;<=>?"
  "\351abcdefghijklmnopqrstuvwxyz\344\366\345\374_"
  "\351abcdefghijklmnopqrstuvwxyz\344\366\345\374\377"
  "\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217"
  "\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"
  "\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"
  "\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"
  "\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"
  "\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"
  "\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"
  "\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377";

static void do_open(int fd, uint16_t ix, char *name)
{
  char *path, *p, *p0;
  int opl;
  int i;
  bool nodot;
  struct file_data *fm;
  int err;
  static const char *modes[6] = {"r+t", "r+b", "w+t", "w+b", "rt", "rb" };

  name[11] = '\0';

  if (!file_op_dir) {
    send_reply(fd, 128+42);	/* Skivan ej klar */
    return;
  }

  do_close(-1, ix);

  opl = strlen(file_op_dir);
  path = alloca(opl+14);
  memcpy(path, file_op_dir, opl);
  p = path+opl;
  if (p[-1] != '/')
    *p++ = '/';

  nodot = true;
  p0 = p;
  for (i = 0; i < 11; i++) {
    if (name[i] != ' ') {
      if (i >= 8 && nodot) {
	*p++ = '.';
	nodot = false;
      }
      *p++ = my_tolower[(unsigned char)name[i]];
    }
  }
  
  if (p == p0) {
    /* Empty filename */
    send_reply(fd, 128+21);	/* File not found */
    return;
  }
  *p = '\0';

  fprintf(stderr, "open %s mode %s\n", path, modes[cmd[0] & 3]);

  fm = calloc(1, sizeof(struct file_info *));
  if (!fm) {
    send_reply(fd, 128+42);
    return;
  }
  
  fm->f = fopen(path, modes[cmd[0] & 3]);
  if (!fm->f && errno == EACCES && !(cmd[0] & 2)) {
    fm->f = fopen(path, modes[(cmd[0] & 1)+4]);
  }
  if (!fm->f) {
    free(fm);
    switch (errno) {
    case EACCES:
      err = 128+39;
      break;
    case EROFS:
      err = 128+43;
      break;
    case EIO:
    case ENOTDIR:
      err = 128+48;
      break;
    default:
      err = 128+21;
      break;
    }
    send_reply(fd, 128+21);
    return;
  }

  filemap[ix] = fm;

  send_reply(fd, 0);
}

static void do_read_block(int fd, uint16_t ix, uint16_t len)
{
  struct file_data *fm = filemap[ix];
  int err;
  unsigned char *data;
  int dlen;

  if (!fm) {
    send_reply(fd, 128+45);
    return;
  }

  data = calloc(len+2, 1);
  if (!data) {
    send_reply(fd, 128+42);	/* "Skivan ej klar" */
    return;
  }

  clearerr(fm->f);
  dlen = fread(data+2, 1, len, fm->f);
  if (dlen == 0) {
    if (ferror(fm->f)) {
      switch (errno) {
      case EBADF:
	err = 128+44;		/* Logisk fil ej öppen */
	break;
      case EIO:
	err = 128+35;		/* Checksummafel vid läsning */
	break;
      default:
	err = 128+48;		/* Fel i biblioteket */
	break;
      }
    } else {
      /* EOF */
      err = 128+34;		/* Slut på filen */
    }
    send_reply(fd, err);
    free(data);
    return;
  }

  send_reply(fd, 0);

  {
    int16_t c = 0;
    int i;
    for (i = 0; i < len; i++)
      c += data[i+2];
    fprintf(stderr, "sending %d bytes, checksum %d\n", len, c);
  }
  data[0] = len;
  data[1] = len >> 8;
  xwrite(fd, data, len+2);
  free(data);
}

#define BUF_SIZE 256

static void do_input(int fd, uint16_t ix)
{
  struct file_data *fm = filemap[ix];
  int err;
  char data[BUF_SIZE], data1[2*BUF_SIZE];
  char *p, *q;
  int dlen;

  if (!fm) {
    send_reply(fd, 128+45);
    return;
  }

  clearerr(fm->f);
  if (!fgets(data, sizeof data, fm->f)) {
    if (ferror(fm->f)) {
      switch (errno) {
      case EBADF:
	err = 128+44;		/* Logisk fil ej öppen */
	break;
      case EIO:
	err = 128+35;		/* Checksummafel vid läsning */
	break;
      default:
	err = 128+48;		/* Fel i biblioteket */
	break;
      }
    } else {
      /* EOF */
      err = 128+34;		/* Slut på filen */
    }
    send_reply(fd, err);
    free(data);
    return;
  }

  /* Strip CR and change LF -> CR LF */
  for (p = data, q = data1+2 ; *p ; p++) {
    switch (*p) {
    case '\r':
      break;
    case '\n':
      *q++ = '\r';
      /* fall through */
    default:
      *q++ = *p;
      break;
    }
  }
  dlen = q - (data1+2);
  data1[0] = dlen;
  data1[1] = dlen >> 8;
  send_reply(fd, 0);
  xwrite(fd, data1, dlen+2);
}

static void do_print(int fd, uint16_t ix, uint16_t len, void *data)
{
  struct file_data *fm = filemap[ix];
  int err;

  if (!fm) {
    send_reply(fd, 128+45);
    return;
  }

  err = 0;
  if (fwrite(data, 1, len, fm->f) != len || fflush(fm->f)) {
    switch (errno) {
    case EACCES:
      err = 128+39;		/* Filen skrivskyddad */
      break;
    case ENOSPC:
    case EFBIG:
      err = 128+41;		/* Skivan full */
      break;
    case EROFS:
      err = 128+43;		/* Skivan skrivskyddad */
      break;
    case EBADF:
      err = 128+44;		/* Logisk fil ej öppen */
      break;
    case EIO:
      err = 128+36;		/* Checksummafel vid skrivning */
      break;
    default:
      err = 128+48;		/* Fel i biblioteket */
      break;
    }
  }
  send_reply(fd, err);
}

bool file_op(unsigned char c, int fd)
{
  static unsigned char *data;
  static char namebuf[12];
  static unsigned char lenbuf[2];
  uint16_t ix, len;

  fprintf(stderr, "<%02X %c>\n", c, isprint(c) ? c : '.');

  *bytep++ = c;
  if (--byte_count)
    return true;		/* More to do... */

  /* Otherwise, we have a full deck of *something* */

  ix  = (cmd[3] << 8) + cmd[2];
  len = (lenbuf[1] << 8) + lenbuf[0];

  switch (state) {
  case st_op:
    switch (cmd[0]) {
    case 0xA0:			/* OPEN TEXT */
    case 0xA1:			/* PREPARE TEXT */
    case 0xA2:			/* OPEN BINARY */
    case 0xA3:			/* PREPARE BINARY */
      bytep = (void *)namebuf;
      byte_count = 11;
      state = st_filename;
      return true;

    case 0xA4:			/* INPUT */
      do_input(fd, ix);
      break;

    case 0xA5:			/* READ BLOCK */
    case 0xA6:			/* PRINT */
      bytep = lenbuf;
      byte_count = 2;
      state = st_len;
      return true;
      
    case 0xA7:			/* CLOSE */
      do_close(fd, ix);
      break;

    case 0xA8:			/* CLOSEALL */
    case 0xA9:
      do_closeall(fd);
      break;

    default:
      /* Unknown command */
      send_reply(fd, 128+11);
      break;
    }
    break;

  case st_filename:
    do_open(fd, ix, namebuf);
    break;

  case st_len:
    switch (cmd[0]) {
    case 0xA5:			/* READ BLOCK */
      do_read_block(fd, ix, len);
      break;
    case 0xA6:			/* PRINT */
      if (data)
	free(data);
      data = malloc(len);
      if (!data)
	send_reply(fd, 128+42);	/* "Skivan ej klar" */
      bytep = data;
      byte_count = len;
      state = st_data;
      return true;
    }
    break;

  case st_data:
    do_print(fd, ix, len, data);
    free(data);
    data = NULL;
    break;
  }

  /* unless otherwise specified, back to command mode */
  bytep = cmd;
  byte_count = 4;
  state = st_op;
  return false;
}