add directory study

study/linux-travel/MINIX-1.5/1.5/Source/commands/vol.c

@@ -0,0 +1,122 @@
+/* vol - break stdin into volumes	Author: Andy Tanenbaum */
+
+/* This program reads standard input and writes it onto diskettes, pausing
+ * at the start of each one.  It's main use is for saving files that are
+ * larger than a single diskette.  Vol just writes its standard input onto
+ * a diskette, and prompts for a new one when it is full.  This mechanism
+ * is transparent to the process producing vol's standard input. For example,
+ *	tar c - . | vol 360 /dev/fd0
+ * puts the tar output as as many diskettes as needed.  To read them back in,
+ * use
+ *	vol -u 360 /dev/fd0 | tar x -
+ *
+ */
+
+#include <sys/types.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <blocksize.h>
+#include <signal.h>
+#include <errno.h>
+
+extern int errno;
+extern char *itoa();
+
+char buffer[BLOCK_SIZE];
+
+main(argc, argv)
+int argc;
+char *argv[];
+{
+  int volume = 1, size, reading, fd, tty;
+  char *p, *name;
+  struct stat stb;
+
+  signal(SIGPIPE, SIG_IGN);
+
+  /* Fetch and verify the arguments. */
+  if (argc != 3 && argc != 4)
+	message("Usage: vol [-u] size block-special\n", "");
+  p = argv[1];
+  reading = (*p == '-' && *(p + 1) == 'u' ? 1 : 0);
+  size = atoi(argv[reading + 1]);
+  name = argv[reading + 2];
+  tty = open("/dev/tty", O_RDONLY);
+
+  if (size <= 0) message("vol: bad volume size\n", argv[reading + 1]);
+  if (stat(name, &stb) < 0) message("vol: cannot stat %s\n", name);
+  if ((stb.st_mode & S_IFMT) != S_IFBLK)
+	message("vol: %s is not a block special file\n", name);
+  if (tty < 0) message("vol: cannot open /dev/tty\n", "");
+
+  while (1) {
+	/* Open the special file. */
+	fd = open(name, 1 - reading);
+	if (fd < 0) message("vol: cannot open %s\n", name);
+
+	std_err("Please insert volume ");
+	num(volume);
+	std_err(" and hit return\n");
+	read(tty, buffer, BLOCK_SIZE);
+	volume++;
+
+	/* Read or write the requisite number of blocks. */
+	if (reading)
+		diskio(size, fd, 1, name, "stdout");	/* vol -u | tar xf - */
+	else
+		diskio(size, 0, fd, "stdin", name);	/* tar cf - | vol */
+
+	close(fd);
+  }
+}
+
+diskio(size, fd1, fd2, errstr1, errstr2)
+int size, fd1, fd2;
+char *errstr1, *errstr2;
+{
+/* Read 'size' blocks from 'fd1' and write them on 'fd2'.  Watch out for
+ * the fact that reads on pipes can return less than the desired data.
+ */
+
+  int n, m, count;
+  long needed;
+
+  needed = (long) BLOCK_SIZE *(long) size;	/* # bytes to read */
+  while (needed > 0L) {
+	count = (needed > (long) BLOCK_SIZE ? BLOCK_SIZE : (int) needed);
+	n = read(fd1, buffer, count);
+	if (n == 0) exit(0);
+	if (n < 0) message("Error encountered while reading %s\n", errstr1);
+	m = write(fd2, buffer, n);
+	if (m < 0 && errno == SIGPIPE) exit(0);
+	if (m > 0 && m != n) message("Output error on %s\n", errstr2);
+	if (m < 0) message("Error encountered while writing %s\n", errstr2);
+	needed -= n;
+  }
+}
+
+
+
+message(s1, s2)
+char *s1, *s2;
+{
+  printf(s1, s2);
+  exit(1);
+}
+
+num(n)
+int n;
+{
+  char out[3];
+
+  out[0] = ' ';
+  out[1] = '0';
+  out[2] = 0;
+  if (n < 10) {
+	out[1] += n;
+  } else {
+	out[1] += (n % 10);
+	out[0] = '0' + (n / 10);
+  }
+  std_err(out);
+}