[distorted-backup] / rmt.c

/* -*-c-*-
 *
 * Fake rmt(8) server for hashing and storing files
 *
 * (c) 2010 Mark Wooding
 */

/*----- Licensing notice --------------------------------------------------*
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program; if not, write to the Free Software Foundation,
 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
 */

/*----- Header files ------------------------------------------------------*/

#define _FILE_OFFSET_BITS 64

#include <ctype.h>
#include <errno.h>
#include <limits.h>
#include <signal.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include <sys/types.h>
#include <unistd.h>
#include <fcntl.h>

#include <getopt.h>

#include <pwd.h>

#include <mLib/dstr.h>
#include <mLib/quis.h>
#include <mLib/report.h>

#include <nettle/sha.h>

/*----- Configuration -----------------------------------------------------*/

#ifndef BKP
#  define BKP "/mnt/bkp"
#endif

/*----- Main code ---------------------------------------------------------*/

#define BUFSZ 10240
#define LSEEK_GET_TAPEPOS 10
#define LSEEK_GO2_TAPEPOS 11

struct flag {
  const char *name;
  int f;
};

static const struct flag openflag[] = {
  /* ;;; Emacs Lisp to generate the table below.  Place your cursor just
     ;;; after the closing `)' and press C-x C-e.

     (let ((flags '(rdonly wronly rdwr creat excl trunc nonblock ndelay
		    noctty append dsync rsync sync cloexec async
		    direct noatime nofollow shlock exlock defer)))
       (save-excursion
	 (goto-char (point-min))
	 (search-forward (concat "***" "BEGIN openflag" "***"))
	 (beginning-of-line 2)
	 (delete-region (point)
			(progn
			  (search-forward "***END***")
			  (beginning-of-line)
			  (point)))
       (dolist (f (sort (copy-list flags) #'string<))
	 (let ((up (upcase (symbol-name f))))
	   (insert (format "#ifdef O_%s\n" up))
	   (insert (format "  { \"%s\", O_%s },\n" up up))
	   (insert "#endif\n")))))
  */
  /***BEGIN openflag***/
#ifdef O_APPEND
  { "APPEND", O_APPEND },
#endif
#ifdef O_ASYNC
  { "ASYNC", O_ASYNC },
#endif
#ifdef O_CLOEXEC
  { "CLOEXEC", O_CLOEXEC },
#endif
#ifdef O_CREAT
  { "CREAT", O_CREAT },
#endif
#ifdef O_DEFER
  { "DEFER", O_DEFER },
#endif
#ifdef O_DIRECT
  { "DIRECT", O_DIRECT },
#endif
#ifdef O_DSYNC
  { "DSYNC", O_DSYNC },
#endif
#ifdef O_EXCL
  { "EXCL", O_EXCL },
#endif
#ifdef O_EXLOCK
  { "EXLOCK", O_EXLOCK },
#endif
#ifdef O_NDELAY
  { "NDELAY", O_NDELAY },
#endif
#ifdef O_NOATIME
  { "NOATIME", O_NOATIME },
#endif
#ifdef O_NOCTTY
  { "NOCTTY", O_NOCTTY },
#endif
#ifdef O_NOFOLLOW
  { "NOFOLLOW", O_NOFOLLOW },
#endif
#ifdef O_NONBLOCK
  { "NONBLOCK", O_NONBLOCK },
#endif
#ifdef O_RDONLY
  { "RDONLY", O_RDONLY },
#endif
#ifdef O_RDWR
  { "RDWR", O_RDWR },
#endif
#ifdef O_RSYNC
  { "RSYNC", O_RSYNC },
#endif
#ifdef O_SHLOCK
  { "SHLOCK", O_SHLOCK },
#endif
#ifdef O_SYNC
  { "SYNC", O_SYNC },
#endif
#ifdef O_TRUNC
  { "TRUNC", O_TRUNC },
#endif
#ifdef O_WRONLY
  { "WRONLY", O_WRONLY },
#endif
  /***END***/
  { 0, 0 }
};

int main(int argc, char *argv[])
{
  int ch;
  dstr d = DSTR_INIT, dd = DSTR_INIT;
  unsigned char buf[BUFSZ];
  int fd = -1, hfd = -1;
  off_t rc;
  off_t off = 0;
  struct passwd *pw;
  uid_t u;
  unsigned f = 0;
#define f_bogus 1u
  const char *p = 0;
  const char *bkp = 0, *host = 0;
  struct sha256_ctx hc;

  ego(argv[0]);
  setvbuf(stdin, 0, _IONBF, 0);
  signal(SIGPIPE, SIG_IGN);

  for (;;) {
    int o = getopt(argc, argv, "H:r:");
    if (o < 0) break;
    switch (o) {
      case 'H': host = optarg; break;
      case 'r': bkp = optarg; break;
      default: f |= f_bogus; break;
    }
  }
  argc -= optind; argv += optind;
  if ((f & f_bogus) || argc) {
    pquis(stderr, "usage: $ [-r ROOT] [-H HOST]\n");
    exit(1);
  }

  if (!bkp) bkp = getenv("BKP");
  if (!bkp) bkp = BKP;

  if (!host) host = getenv("BKP_HOST");

  if (!host) {
    p = getenv("USER");
    if (!p) p = getenv("LOGNAME");
    if (!p) {
      u = getuid();
      if ((pw = getpwuid(u)) == 0)
	die(1, "no passwd entry (you don't exist?)");
      p = pw->pw_name;
    }
    if (strncmp(p, "bkp-", 4) != 0) {
      die(1, "can't deduce host name: "
	  "login name `%s' doesn't begin with `bkp-'",
	  p);
    }
    host = p + 4;
  }

  for (;;) {
    if (fflush(stdout)) goto fail;
    ch = getchar();
    if (ch == EOF) break;
    DRESET(&d); DRESET(&dd); rc = 0;

#define CHECKFD do { if (fd < 0) goto badf; } while (0)
#define ERROR(what) do moan(what ": %s", strerror(errno)); while (0)
#define ERROR1(what, arg) \
  do moan(what ": %s", arg, strerror(errno)); while (0)
#define ARG(d) do {							\
  if (dstr_putline(&d, stdin) == EOF || ferror(stdin) || feof(stdin))	\
    { moan("read (stdin)", strerror(errno)); goto fail; }		\
} while (0)

#define SKIPWS do { while (isspace((unsigned char)*p)) p++; } while (0)

    switch (ch) {

      case 'O': {
	/* Ofile\nmode\n -- open file */

	const struct flag *ff;
	char *p, *q;
	size_t n;
	long mode, f;

	ARG(d); ARG(dd);
	if (fd >= 0 && close(fd)) ERROR("close (fd)");
	if (hfd >= 0 && close(hfd)) ERROR("close (hash)");
	fd = hfd = -1;

	if (chdir(bkp) || chdir(host)) ERROR1("chdir (%s)", host);
	p = d.buf;
	if ((q = strchr(p, '/')) == 0)
	  { moan("bad path: missing `/')"); goto inval; }
	*q++ = 0;
	if (chdir(p) || chdir("prepare/incoming")) ERROR1("chdir (%s)", p);

	memmove(d.buf, q, d.len - (q - d.buf) + 1);
	d.len -= q - d.buf;

	errno = 0;
	mode = strtol(dd.buf, &p, 0);
	if (errno) ERROR("bad mode");
	else if (mode < 0 || mode > INT_MAX)
	  { moan("bad mode: range"); goto range; }
	SKIPWS;
	if (!*p) {
	  switch (mode & O_ACCMODE) {
	    case O_RDONLY: mode = O_RDONLY; break;
	    case O_WRONLY: mode = O_WRONLY | O_TRUNC | O_CREAT; break;
	    case O_RDWR: mode = O_RDWR;
	    default: moan("bad mode: unknown access type"); goto inval;
	  }
	} else {
	  mode = 0;
	  for (;;) {
	    if (p[0] == 'O' && p[1] == '_') {
	      p += 2;
	      n = strcspn(p, " \t|");
	      for (ff = openflag; ff->name; ff++) {
		if (strncmp(p, ff->name, n) == 0 && !ff->name[n])
		  goto ofmatch;
	      }
	      moan("bad mode: unknown flag O_%.*s", (int)n, p);
	      goto inval;
	    ofmatch:
	      mode |= ff->f;
	      p += n;
	    } else if (isdigit((unsigned long)*p)) {
	      errno = 0;
	      f = strtol(p, &p, 0);
	      if (errno) ERROR("bad mode");
	      else if (f < 0 || f > INT_MAX)
		{ moan("bad mode: range"); goto range; }
	      mode |= f;
	    } else {
	      moan("bad mode: unexpected token");
	      goto inval;
	    }
	    SKIPWS;
	    if (!*p)
	      break;
	    else if (*p != '|') {
	      moan("bad mode: expected `|'");
	      goto inval;
	    }
	    p++;
	    SKIPWS;
	  }
	}

	if ((fd = open(d.buf, mode, 0666)) < 0) ERROR1("open (%s)", d.buf);
	if ((mode & O_ACCMODE) == O_WRONLY) {
	  DPUTS(&d, ".hash");
	  if ((hfd = open(d.buf,
			 mode & (O_ACCMODE | O_CREAT | O_EXCL | O_TRUNC),
			 0666)) < 0) {
	    close(fd); fd = -1;
	    ERROR1("open (%s)", d.buf);
	  }
	  sha256_init(&hc);
	}
	off = 0;
      } break;

      case 'C': {
	/* Chunoz\n -- close file */

	uint8_t h[SHA256_DIGEST_SIZE], *p;
	char hex[SHA256_DIGEST_SIZE * 2 + 1], *q;
	unsigned i;

	ARG(d); CHECKFD;
	if (close(fd)) ERROR("close (fd)");
	fd = -1;
	if (hfd >= 0) {
	  sha256_digest(&hc, sizeof(h), h);
	  for (p = h, q = hex; p < h + sizeof(h); p++, q += 2)
	    sprintf(q, "%02x", *p);
	  *q++ = '\n';
	  errno = EIO;
	  if (write(hfd, hex, sizeof(hex)) < sizeof(hex) || close(hfd))
	    ERROR("close (hash)");
	  hfd = -1;
	}
      } break;

      case 'L': {
	/* Loffset\nwhence\n -- seek
	 *  (warning: the manual page gets these the wrong way round)
	 */

	int whence;
	off_t offset;

	ARG(d); ARG(dd); CHECKFD;
	offset = atoi(d.buf); whence = strtoull(dd.buf, 0, 0);
	switch (whence) {
	  case LSEEK_GET_TAPEPOS: whence = SEEK_CUR; offset = 0; break;
	  case LSEEK_GO2_TAPEPOS: whence = SEEK_SET; break;
	}
	switch (whence) {
	  case SEEK_CUR:
	    if (!offset) { rc = off; break; }
	  default:
	    rc = lseek(fd, offset, whence);
	    if (rc == (off_t)-1) ERROR("seek");
	    off = rc;
	    break;
	}
      } break;

      case 'W': {
	/* Wlen\ndata... -- write */

	size_t n, nn, sz;
	ssize_t ssz;
	unsigned char *p;
	int botch = 0;

	ARG(d); CHECKFD;
	rc = sz = strtoul(d.buf, 0, 0);
	while (sz) {
	  nn = sz > BUFSZ ? BUFSZ : sz;
	  n = fread(buf, 1, nn, stdin);
	  if (n < nn) {
	    if (feof(stdin)) { moan("eof on stdin"); goto fail;}
	    else ERROR("read (stdin)");
	  }
	  if (hfd >= 0) sha256_update(&hc, n, buf);
	  p = buf;
	  while (!botch && n) {
	    if ((ssz = write(fd, p, n)) > 0) {
	      p += ssz; off += ssz; n -= ssz;
	    } else if (!ssz) { moan("zero-length write"); goto fail; }
	    else if (errno != EINTR) { botch = errno; }
	  }
	  sz -= nn;
	}
	if (botch) { errno = botch; ERROR("write"); }
      } break;

      case 'R': {
	/* Rlen\n -- read */

	size_t nn;
	ssize_t ssz;

	ARG(d); CHECKFD;
	nn = strtoul(d.buf, 0, 0); if (nn > BUFSZ) nn = BUFSZ;
	if ((ssz = read(fd, buf, nn)) < 0) ERROR("read");
	off += ssz;
	printf("A%ld\n", (long)ssz);
	if (fwrite(buf, 1, ssz, stdout) < ssz)
	  { moan("write (stdout): %s", strerror(errno)); goto fail; }
	continue;
      } break;

      case 'i': case 'I':
	/* Iop\ncount\n -- ioctl */
	ARG(d); ARG(dd); CHECKFD; goto notty;

      case 'S':
	/* S -- ioctl */
	CHECKFD; goto notty;
      case 's':
	/* sop -- ioctl */

	if ((ch = getchar()) == EOF) goto fail;
	CHECKFD; goto notty;

      default:
	goto fail;
    }

    printf("A%llu\n", (unsigned long long)rc);
    continue;

  badf: errno = EBADF; goto error;
  range: errno = ERANGE; goto error;
  inval: errno = EINVAL; goto error;
  notty: errno = ENOTTY; goto error;
  error:
    printf("E%d\n%s\n", errno, strerror(errno));
    continue;
  }
  if (fflush(stdout) || ferror(stdout) || ferror(stdin)) goto fail;
  return (0);
fail:
  return (1);
}

/*----- That's all, folks -------------------------------------------------*/
Commit	Line	Data
99248ed2 MW	1	/* --c--
	2	*
	3	* Fake rmt(8) server for hashing and storing files
	4	*
	5	* (c) 2010 Mark Wooding
	6	*/
	7
	8	/----- Licensing notice --------------------------------------------------
	9	*
	10	* This program is free software; you can redistribute it and/or modify
	11	* it under the terms of the GNU General Public License as published by
	12	* the Free Software Foundation; either version 2 of the License, or
	13	* (at your option) any later version.
	14	*
	15	* This program is distributed in the hope that it will be useful,
	16	* but WITHOUT ANY WARRANTY; without even the implied warranty of
	17	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	18	* GNU General Public License for more details.
	19	*
	20	* You should have received a copy of the GNU General Public License
	21	* along with this program; if not, write to the Free Software Foundation,
	22	* Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
	23	*/
	24
	25	/----- Header files ------------------------------------------------------/
	26
	27	#define _FILE_OFFSET_BITS 64
	28
	29	#include <ctype.h>
	30	#include <errno.h>
	31	#include <limits.h>
	32	#include <signal.h>
	33	#include <stdio.h>
	34	#include <stdlib.h>
	35	#include <string.h>
	36
	37	#include <sys/types.h>
	38	#include <unistd.h>
	39	#include <fcntl.h>
	40
	41	#include <getopt.h>
	42
	43	#include <pwd.h>
	44
	45	#include <mLib/dstr.h>
	46	#include <mLib/quis.h>
	47	#include <mLib/report.h>
	48
	49	#include <nettle/sha.h>
	50
	51	/----- Configuration -----------------------------------------------------/
	52
	53	#ifndef BKP
	54	# define BKP "/mnt/bkp"
	55	#endif
	56
	57	/----- Main code ---------------------------------------------------------/
	58
	59	#define BUFSZ 10240
	60	#define LSEEK_GET_TAPEPOS 10
	61	#define LSEEK_GO2_TAPEPOS 11
	62
	63	struct flag {
	64	const char *name;
65	int f;
66	};
67
68	static const struct flag openflag[] = {
69	/* ;;; Emacs Lisp to generate the table below. Place your cursor just
70	;;; after the closing `)' and press C-x C-e.
71
72	(let ((flags '(rdonly wronly rdwr creat excl trunc nonblock ndelay
73	noctty append dsync rsync sync cloexec async
74	direct noatime nofollow shlock exlock defer)))
75	(save-excursion
76	(goto-char (point-min))
77	(search-forward (concat "*" "BEGIN openflag" "*"))
78	(beginning-of-line 2)
79	(delete-region (point)
80	(progn
81	(search-forward "*END*")
82	(beginning-of-line)
83	(point)))
84	(dolist (f (sort (copy-list flags) #'string<))
85	(let ((up (upcase (symbol-name f))))
86	(insert (format "#ifdef O_%s\n" up))
87	(insert (format " { \"%s\", O_%s },\n" up up))
88	(insert "#endif\n")))))
89	*/
90	/*BEGIN openflag*/
91	#ifdef O_APPEND
92	{ "APPEND", O_APPEND },
93	#endif
94	#ifdef O_ASYNC
95	{ "ASYNC", O_ASYNC },
96	#endif
97	#ifdef O_CLOEXEC
98	{ "CLOEXEC", O_CLOEXEC },
99	#endif
100	#ifdef O_CREAT
101	{ "CREAT", O_CREAT },
102	#endif
103	#ifdef O_DEFER
104	{ "DEFER", O_DEFER },
105	#endif
106	#ifdef O_DIRECT
107	{ "DIRECT", O_DIRECT },
108	#endif
109	#ifdef O_DSYNC
110	{ "DSYNC", O_DSYNC },
111	#endif
112	#ifdef O_EXCL
113	{ "EXCL", O_EXCL },
114	#endif
115	#ifdef O_EXLOCK
116	{ "EXLOCK", O_EXLOCK },
117	#endif
118	#ifdef O_NDELAY
119	{ "NDELAY", O_NDELAY },
120	#endif
121	#ifdef O_NOATIME
122	{ "NOATIME", O_NOATIME },
123	#endif
124	#ifdef O_NOCTTY
125	{ "NOCTTY", O_NOCTTY },
126	#endif
127	#ifdef O_NOFOLLOW
128	{ "NOFOLLOW", O_NOFOLLOW },
129	#endif
130	#ifdef O_NONBLOCK
131	{ "NONBLOCK", O_NONBLOCK },
132	#endif
133	#ifdef O_RDONLY
134	{ "RDONLY", O_RDONLY },
135	#endif
136	#ifdef O_RDWR
137	{ "RDWR", O_RDWR },
138	#endif
139	#ifdef O_RSYNC
140	{ "RSYNC", O_RSYNC },
141	#endif
142	#ifdef O_SHLOCK
143	{ "SHLOCK", O_SHLOCK },
144	#endif
145	#ifdef O_SYNC
146	{ "SYNC", O_SYNC },
147	#endif
148	#ifdef O_TRUNC
149	{ "TRUNC", O_TRUNC },
150	#endif
151	#ifdef O_WRONLY
152	{ "WRONLY", O_WRONLY },
153	#endif
154	/*END*/
155	{ 0, 0 }
156	};
157
158	int main(int argc, char *argv[])
159	{
160	int ch;
161	dstr d = DSTR_INIT, dd = DSTR_INIT;
162	unsigned char buf[BUFSZ];
163	int fd = -1, hfd = -1;
164	off_t rc;
165	off_t off = 0;
166	struct passwd *pw;
167	uid_t u;
168	unsigned f = 0;
169	#define f_bogus 1u
170	const char *p = 0;
171	const char bkp = 0, host = 0;
172	struct sha256_ctx hc;
173
174	ego(argv[0]);
175	setvbuf(stdin, 0, _IONBF, 0);
176	signal(SIGPIPE, SIG_IGN);
177
178	for (;;) {
179	int o = getopt(argc, argv, "H:r:");
180	if (o < 0) break;
181	switch (o) {
182	case 'H': host = optarg; break;
183	case 'r': bkp = optarg; break;
184	default: f \|= f_bogus; break;
185	}
186	}
187	argc -= optind; argv += optind;
188	if ((f & f_bogus) \|\| argc) {
189	pquis(stderr, "usage: $ [-r ROOT] [-H HOST]\n");
190	exit(1);
191	}
192
193	if (!bkp) bkp = getenv("BKP");
194	if (!bkp) bkp = BKP;
195
196	if (!host) host = getenv("BKP_HOST");
197
198	if (!host) {
199	p = getenv("USER");
200	if (!p) p = getenv("LOGNAME");
201	if (!p) {
202	u = getuid();
203	if ((pw = getpwuid(u)) == 0)
204	die(1, "no passwd entry (you don't exist?)");
205	p = pw->pw_name;
206	}
207	if (strncmp(p, "bkp-", 4) != 0) {
208	die(1, "can't deduce host name: "
209	"login name `%s' doesn't begin with `bkp-'",
210	p);
211	}
212	host = p + 4;
213	}
214
215	for (;;) {
216	if (fflush(stdout)) goto fail;
217	ch = getchar();
218	if (ch == EOF) break;
219	DRESET(&d); DRESET(&dd); rc = 0;
220
221	#define CHECKFD do { if (fd < 0) goto badf; } while (0)
222	#define ERROR(what) do moan(what ": %s", strerror(errno)); while (0)
223	#define ERROR1(what, arg) \
224	do moan(what ": %s", arg, strerror(errno)); while (0)
225	#define ARG(d) do { \
226	if (dstr_putline(&d, stdin) == EOF \|\| ferror(stdin) \|\| feof(stdin)) \
227	{ moan("read (stdin)", strerror(errno)); goto fail; } \
228	} while (0)
229
230	#define SKIPWS do { while (isspace((unsigned char)*p)) p++; } while (0)
231
232	switch (ch) {
233
234	case 'O': {
235	/* Ofile\nmode\n -- open file */
236
237	const struct flag *ff;
238	char p, q;
239	size_t n;
240	long mode, f;
241
242	ARG(d); ARG(dd);
243	if (fd >= 0 && close(fd)) ERROR("close (fd)");
244	if (hfd >= 0 && close(hfd)) ERROR("close (hash)");
245	fd = hfd = -1;
246
247	if (chdir(bkp) \|\| chdir(host)) ERROR1("chdir (%s)", host);
248	p = d.buf;
249	if ((q = strchr(p, '/')) == 0)
250	{ moan("bad path: missing `/')"); goto inval; }
251	*q++ = 0;
252	if (chdir(p) \|\| chdir("prepare/incoming")) ERROR1("chdir (%s)", p);
253
254	memmove(d.buf, q, d.len - (q - d.buf) + 1);
255	d.len -= q - d.buf;
256
257	errno = 0;
258	mode = strtol(dd.buf, &p, 0);
259	if (errno) ERROR("bad mode");
260	else if (mode < 0 \|\| mode > INT_MAX)
261	{ moan("bad mode: range"); goto range; }
262	SKIPWS;
263	if (!*p) {
264	switch (mode & O_ACCMODE) {
265	case O_RDONLY: mode = O_RDONLY; break;
266	case O_WRONLY: mode = O_WRONLY \| O_TRUNC \| O_CREAT; break;
267	case O_RDWR: mode = O_RDWR;
268	default: moan("bad mode: unknown access type"); goto inval;
269	}
270	} else {
271	mode = 0;
272	for (;;) {
273	if (p[0] == 'O' && p[1] == '_') {
274	p += 2;
275	n = strcspn(p, " \t\|");
276	for (ff = openflag; ff->name; ff++) {
277	if (strncmp(p, ff->name, n) == 0 && !ff->name[n])
278	goto ofmatch;
279	}
280	moan("bad mode: unknown flag O_%.*s", (int)n, p);
281	goto inval;
282	ofmatch:
283	mode \|= ff->f;
284	p += n;
285	} else if (isdigit((unsigned long)*p)) {
286	errno = 0;
287	f = strtol(p, &p, 0);
288	if (errno) ERROR("bad mode");
289	else if (f < 0 \|\| f > INT_MAX)
290	{ moan("bad mode: range"); goto range; }
291	mode \|= f;
292	} else {
293	moan("bad mode: unexpected token");
294	goto inval;
295	}
296	SKIPWS;
297	if (!*p)
298	break;
299	else if (*p != '\|') {
300	moan("bad mode: expected `\|'");
301	goto inval;
302	}
303	p++;
304	SKIPWS;
305	}
306	}
307
308	if ((fd = open(d.buf, mode, 0666)) < 0) ERROR1("open (%s)", d.buf);
309	if ((mode & O_ACCMODE) == O_WRONLY) {
310	DPUTS(&d, ".hash");
311	if ((hfd = open(d.buf,
312	mode & (O_ACCMODE \| O_CREAT \| O_EXCL \| O_TRUNC),
313	0666)) < 0) {
314	close(fd); fd = -1;
315	ERROR1("open (%s)", d.buf);
316	}
317	sha256_init(&hc);
318	}
319	off = 0;
320	} break;
321
322	case 'C': {
323	/* Chunoz\n -- close file */
324
325	uint8_t h[SHA256_DIGEST_SIZE], *p;
326	char hex[SHA256_DIGEST_SIZE * 2 + 1], *q;
327	unsigned i;
328
329	ARG(d); CHECKFD;
330	if (close(fd)) ERROR("close (fd)");
331	fd = -1;
332	if (hfd >= 0) {
333	sha256_digest(&hc, sizeof(h), h);
334	for (p = h, q = hex; p < h + sizeof(h); p++, q += 2)
335	sprintf(q, "%02x", *p);
336	*q++ = '\n';
337	errno = EIO;
338	if (write(hfd, hex, sizeof(hex)) < sizeof(hex) \|\| close(hfd))
339	ERROR("close (hash)");
340	hfd = -1;
341	}
342	} break;
343
344	case 'L': {
345	/* Loffset\nwhence\n -- seek
346	* (warning: the manual page gets these the wrong way round)
347	*/
348
349	int whence;
350	off_t offset;
351
352	ARG(d); ARG(dd); CHECKFD;
353	offset = atoi(d.buf); whence = strtoull(dd.buf, 0, 0);
354	switch (whence) {
355	case LSEEK_GET_TAPEPOS: whence = SEEK_CUR; offset = 0; break;
356	case LSEEK_GO2_TAPEPOS: whence = SEEK_SET; break;
357	}
358	switch (whence) {
359	case SEEK_CUR:
360	if (!offset) { rc = off; break; }
361	default:
362	rc = lseek(fd, offset, whence);
363	if (rc == (off_t)-1) ERROR("seek");
364	off = rc;
365	break;
366	}
367	} break;
368
369	case 'W': {
370	/* Wlen\ndata... -- write */
371
372	size_t n, nn, sz;
373	ssize_t ssz;
374	unsigned char *p;
375	int botch = 0;
376
377	ARG(d); CHECKFD;
378	rc = sz = strtoul(d.buf, 0, 0);
379	while (sz) {
380	nn = sz > BUFSZ ? BUFSZ : sz;
381	n = fread(buf, 1, nn, stdin);
382	if (n < nn) {
383	if (feof(stdin)) { moan("eof on stdin"); goto fail;}
384	else ERROR("read (stdin)");
385	}
386	if (hfd >= 0) sha256_update(&hc, n, buf);
387	p = buf;
388	while (!botch && n) {
389	if ((ssz = write(fd, p, n)) > 0) {
390	p += ssz; off += ssz; n -= ssz;
391	} else if (!ssz) { moan("zero-length write"); goto fail; }
392	else if (errno != EINTR) { botch = errno; }
393	}
394	sz -= nn;
395	}
396	if (botch) { errno = botch; ERROR("write"); }
397	} break;
398
399	case 'R': {
400	/* Rlen\n -- read */
401
402	size_t nn;
403	ssize_t ssz;
404
405	ARG(d); CHECKFD;
406	nn = strtoul(d.buf, 0, 0); if (nn > BUFSZ) nn = BUFSZ;
407	if ((ssz = read(fd, buf, nn)) < 0) ERROR("read");
408	off += ssz;
409	printf("A%ld\n", (long)ssz);
410	if (fwrite(buf, 1, ssz, stdout) < ssz)
411	{ moan("write (stdout): %s", strerror(errno)); goto fail; }
412	continue;
413	} break;
414
415	case 'i': case 'I':
416	/* Iop\ncount\n -- ioctl */
417	ARG(d); ARG(dd); CHECKFD; goto notty;
418
419	case 'S':
420	/* S -- ioctl */
421	CHECKFD; goto notty;
422	case 's':
423	/* sop -- ioctl */
424
425	if ((ch = getchar()) == EOF) goto fail;
426	CHECKFD; goto notty;
427
428	default:
429	goto fail;
430	}
431
432	printf("A%llu\n", (unsigned long long)rc);
433	continue;
434
435	badf: errno = EBADF; goto error;
436	range: errno = ERANGE; goto error;
437	inval: errno = EINVAL; goto error;
438	notty: errno = ENOTTY; goto error;
439	error:
440	printf("E%d\n%s\n", errno, strerror(errno));
441	continue;
442	}
443	if (fflush(stdout) \|\| ferror(stdout) \|\| ferror(stdin)) goto fail;
444	return (0);
445	fail:
446	return (1);
447	}
448
449	/----- That's all, folks -------------------------------------------------/