1 /* Functions for communicating with a remote tape drive.
3 Copyright 1988, 1992, 1994, 1996, 1997, 1999, 2000, 2001 Free Software
6 This program is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 This program is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with this program; if not, write to the Free Software Foundation,
18 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
20 /* The man page rmt(8) for /etc/rmt documents the remote mag tape protocol
21 which rdump and rrestore use. Unfortunately, the man page is *WRONG*.
22 The author of the routines I'm including originally wrote his code just
23 based on the man page, and it didn't work, so he went to the rdump source
24 to figure out why. The only thing he had to change was to check for the
25 'F' return code in addition to the 'E', and to separate the various
26 arguments with \n instead of a space. I personally don't think that this
27 is much of a problem, but I wanted to point it out. -- Arnold Robbins
29 Originally written by Jeff Lee, modified some by Arnold Robbins. Redone
30 as a library that can replace open, read, write, etc., by Fred Fish, with
31 some additional work by Arnold Robbins. Modified to make all rmt* calls
32 into macros for speed by Jay Fenlason. Use -DWITH_REXEC for rexec
33 code, courtesy of Dan Kegel. */
39 #include <safe-read.h>
40 #include <full-write.h>
42 /* Try hard to get EOPNOTSUPP defined. 486/ISC has it in net/errno.h,
43 3B2/SVR3 has it in sys/inet.h. Otherwise, like on MSDOS, use EINVAL. */
47 # include <net/errno.h>
50 # include <sys/inet.h>
53 # define EOPNOTSUPP EINVAL
65 /* Exit status if exec errors. */
66 #define EXIT_ON_EXEC_ERROR 128
68 /* FIXME: Size of buffers for reading and writing commands to rmt. */
69 #define COMMAND_BUFFER_SIZE 64
72 # define RETSIGTYPE void
75 /* FIXME: Maximum number of simultaneous remote tape connections. */
78 #define PREAD 0 /* read file descriptor from pipe() */
79 #define PWRITE 1 /* write file descriptor from pipe() */
81 /* Return the parent's read side of remote tape connection Fd. */
82 #define READ_SIDE(Fd) (from_remote[Fd][PREAD])
84 /* Return the parent's write side of remote tape connection Fd. */
85 #define WRITE_SIDE(Fd) (to_remote[Fd][PWRITE])
87 /* The pipes for receiving data from remote tape drives. */
88 static int from_remote[MAXUNIT][2] = {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}};
90 /* The pipes for sending data to remote tape drives. */
91 static int to_remote[MAXUNIT][2] = {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}};
93 /* Temporary variable used by macros in rmt.h. */
97 /* Close remote tape connection HANDLE, and reset errno to ERRNO_VALUE. */
99 _rmt_shutdown (int handle, int errno_value)
101 close (READ_SIDE (handle));
102 close (WRITE_SIDE (handle));
103 READ_SIDE (handle) = -1;
104 WRITE_SIDE (handle) = -1;
108 /* Attempt to perform the remote tape command specified in BUFFER on
109 remote tape connection HANDLE. Return 0 if successful, -1 on
112 do_command (int handle, const char *buffer)
114 /* Save the current pipe handler and try to make the request. */
116 size_t length = strlen (buffer);
117 RETSIGTYPE (*pipe_handler) () = signal (SIGPIPE, SIG_IGN);
118 ssize_t written = full_write (WRITE_SIDE (handle), buffer, length);
119 signal (SIGPIPE, pipe_handler);
121 if (written == length)
124 /* Something went wrong. Close down and go home. */
126 _rmt_shutdown (handle, EIO);
131 get_status_string (int handle, char *command_buffer)
136 /* Read the reply command line. */
138 for (counter = 0, cursor = command_buffer;
139 counter < COMMAND_BUFFER_SIZE;
142 if (safe_read (READ_SIDE (handle), cursor, 1) != 1)
144 _rmt_shutdown (handle, EIO);
154 if (counter == COMMAND_BUFFER_SIZE)
156 _rmt_shutdown (handle, EIO);
160 /* Check the return status. */
162 for (cursor = command_buffer; *cursor; cursor++)
166 if (*cursor == 'E' || *cursor == 'F')
168 errno = atoi (cursor + 1);
170 /* Skip the error message line. */
172 /* FIXME: there is better to do than merely ignoring error messages
173 coming from the remote end. Translate them, too... */
178 while (safe_read (READ_SIDE (handle), &character, 1) == 1)
179 if (character == '\n')
184 _rmt_shutdown (handle, errno);
189 /* Check for mis-synced pipes. */
193 _rmt_shutdown (handle, EIO);
197 /* Got an `A' (success) response. */
202 /* Read and return the status from remote tape connection HANDLE. If
203 an error occurred, return -1 and set errno. */
205 get_status (int handle)
207 char command_buffer[COMMAND_BUFFER_SIZE];
208 const char *status = get_status_string (handle, command_buffer);
209 return status ? atol (status) : -1L;
213 get_status_off (int handle)
215 char command_buffer[COMMAND_BUFFER_SIZE];
216 const char *status = get_status_string (handle, command_buffer);
222 /* Parse status, taking care to check for overflow.
223 We can't use standard functions,
224 since off_t might be longer than long. */
229 for (; *status == ' ' || *status == '\t'; status++)
232 negative = *status == '-';
233 status += negative || *status == '+';
237 int digit = *status++ - '0';
238 if (9 < (unsigned) digit)
242 off_t c10 = 10 * count;
243 off_t nc = negative ? c10 - digit : c10 + digit;
244 if (c10 / 10 != count || (negative ? c10 < nc : nc < c10))
256 /* Execute /etc/rmt as user USER on remote system HOST using rexec.
257 Return a file descriptor of a bidirectional socket for stdin and
258 stdout. If USER is zero, use the current username.
260 By default, this code is not used, since it requires that the user
261 have a .netrc file in his/her home directory, or that the
262 application designer be willing to have rexec prompt for login and
263 password info. This may be unacceptable, and .rhosts files for use
264 with rsh are much more common on BSD systems. */
266 _rmt_rexec (char *host, char *user)
268 int saved_stdin = dup (STDIN_FILENO);
269 int saved_stdout = dup (STDOUT_FILENO);
270 struct servent *rexecserv;
273 /* When using cpio -o < filename, stdin is no longer the tty. But the
274 rexec subroutine reads the login and the passwd on stdin, to allow
275 remote execution of the command. So, reopen stdin and stdout on
276 /dev/tty before the rexec and give them back their original value
279 if (! freopen ("/dev/tty", "r", stdin))
280 freopen ("/dev/null", "r", stdin);
281 if (! freopen ("/dev/tty", "w", stdout))
282 freopen ("/dev/null", "w", stdout);
284 if (rexecserv = getservbyname ("exec", "tcp"), !rexecserv)
285 error (EXIT_ON_EXEC_ERROR, 0, _("exec/tcp: Service not available"));
287 result = rexec (&host, rexecserv->s_port, user, 0, "/etc/rmt", 0);
288 if (fclose (stdin) == EOF)
289 error (0, errno, _("stdin"));
290 fdopen (saved_stdin, "r");
291 if (fclose (stdout) == EOF)
292 error (0, errno, _("stdout"));
293 fdopen (saved_stdout, "w");
298 #endif /* WITH_REXEC */
300 /* Place into BUF a string representing OFLAG, which must be suitable
301 as argument 2 of `open'. BUF must be large enough to hold the
302 result. This function should generate a string that decode_oflag
305 encode_oflag (char *buf, int oflag)
307 sprintf (buf, "%d ", oflag);
309 switch (oflag & O_ACCMODE)
311 case O_RDONLY: strcat (buf, "O_RDONLY"); break;
312 case O_RDWR: strcat (buf, "O_RDWR"); break;
313 case O_WRONLY: strcat (buf, "O_WRONLY"); break;
318 if (oflag & O_APPEND) strcat (buf, "|O_APPEND");
320 if (oflag & O_CREAT) strcat (buf, "|O_CREAT");
322 if (oflag & O_DSYNC) strcat (buf, "|O_DSYNC");
324 if (oflag & O_EXCL) strcat (buf, "|O_EXCL");
326 if (oflag & O_LARGEFILE) strcat (buf, "|O_LARGEFILE");
329 if (oflag & O_NOCTTY) strcat (buf, "|O_NOCTTY");
332 if (oflag & O_NONBLOCK) strcat (buf, "|O_NONBLOCK");
335 if (oflag & O_RSYNC) strcat (buf, "|O_RSYNC");
338 if (oflag & O_SYNC) strcat (buf, "|O_SYNC");
340 if (oflag & O_TRUNC) strcat (buf, "|O_TRUNC");
343 /* Open a file (a magnetic tape device?) on the system specified in
344 PATH, as the given user. PATH has the form `[USER@]HOST:FILE'.
345 OPEN_MODE is O_RDONLY, O_WRONLY, etc. If successful, return the
346 remote pipe number plus BIAS. REMOTE_SHELL may be overridden. On
349 rmt_open__ (const char *path, int open_mode, int bias, const char *remote_shell)
351 int remote_pipe_number; /* pseudo, biased file descriptor */
352 char *path_copy ; /* copy of path string */
353 char *remote_host; /* remote host name */
354 char *remote_file; /* remote file name (often a device) */
355 char *remote_user; /* remote user name */
357 /* Find an unused pair of file descriptors. */
359 for (remote_pipe_number = 0;
360 remote_pipe_number < MAXUNIT;
361 remote_pipe_number++)
362 if (READ_SIDE (remote_pipe_number) == -1
363 && WRITE_SIDE (remote_pipe_number) == -1)
366 if (remote_pipe_number == MAXUNIT)
372 /* Pull apart the system and device, and optional user. */
377 path_copy = xstrdup (path);
378 remote_host = path_copy;
382 for (cursor = path_copy; *cursor; cursor++)
389 /* Do not allow newlines in the path, since the protocol
390 uses newline delimiters. */
398 remote_user = remote_host;
400 remote_host = cursor + 1;
408 remote_file = cursor + 1;
414 /* FIXME: Should somewhat validate the decoding, here. */
416 if (remote_user && *remote_user == '\0')
421 /* Execute the remote command using rexec. */
423 READ_SIDE (remote_pipe_number) = _rmt_rexec (remote_host, remote_user);
424 if (READ_SIDE (remote_pipe_number) < 0)
432 WRITE_SIDE (remote_pipe_number) = READ_SIDE (remote_pipe_number);
434 #else /* not WITH_REXEC */
436 const char *remote_shell_basename;
439 /* Identify the remote command to be executed. */
442 remote_shell = getenv("TAR_RSH");
447 remote_shell = REMOTE_SHELL;
454 remote_shell_basename = base_name (remote_shell);
456 /* Set up the pipes for the `rsh' command, and fork. */
458 if (pipe (to_remote[remote_pipe_number]) == -1
459 || pipe (from_remote[remote_pipe_number]) == -1)
480 close (STDIN_FILENO);
481 dup (to_remote[remote_pipe_number][PREAD]);
482 close (to_remote[remote_pipe_number][PREAD]);
483 close (to_remote[remote_pipe_number][PWRITE]);
485 close (STDOUT_FILENO);
486 dup (from_remote[remote_pipe_number][PWRITE]);
487 close (from_remote[remote_pipe_number][PREAD]);
488 close (from_remote[remote_pipe_number][PWRITE]);
496 execlp (remote_shell, remote_shell_basename, "-l", remote_user,
497 remote_host, "/etc/rmt", (char *) 0);
499 execlp (remote_shell, remote_shell_basename, remote_host,
500 "/etc/rmt", (char *) 0);
502 /* Bad problems if we get here. */
504 /* In a previous version, _exit was used here instead of exit. */
505 error (EXIT_ON_EXEC_ERROR, errno, _("Cannot execute remote shell"));
510 close (from_remote[remote_pipe_number][PWRITE]);
511 close (to_remote[remote_pipe_number][PREAD]);
513 #endif /* not WITH_REXEC */
515 /* Attempt to open the tape device. */
518 size_t remote_file_len = strlen (remote_file);
519 char *command_buffer = xmalloc (remote_file_len + 1000);
520 sprintf (command_buffer, "O%s\n", remote_file);
521 encode_oflag (command_buffer + remote_file_len + 2, open_mode);
522 strcat (command_buffer, "\n");
523 if (do_command (remote_pipe_number, command_buffer) == -1
524 || get_status (remote_pipe_number) == -1)
527 free (command_buffer);
529 _rmt_shutdown (remote_pipe_number, e);
532 free (command_buffer);
536 return remote_pipe_number + bias;
539 /* Close remote tape connection HANDLE and shut down. Return 0 if
540 successful, -1 on error. */
542 rmt_close__ (int handle)
546 if (do_command (handle, "C\n") == -1)
549 status = get_status (handle);
550 _rmt_shutdown (handle, errno);
554 /* Read up to LENGTH bytes into BUFFER from remote tape connection HANDLE.
555 Return the number of bytes read on success, -1 on error. */
557 rmt_read__ (int handle, char *buffer, size_t length)
559 char command_buffer[COMMAND_BUFFER_SIZE];
560 ssize_t status, rlen;
563 sprintf (command_buffer, "R%lu\n", (unsigned long) length);
564 if (do_command (handle, command_buffer) == -1
565 || (status = get_status (handle)) == -1)
568 for (counter = 0; counter < status; counter += rlen, buffer += rlen)
570 rlen = safe_read (READ_SIDE (handle), buffer, status - counter);
573 _rmt_shutdown (handle, EIO);
581 /* Write LENGTH bytes from BUFFER to remote tape connection HANDLE.
582 Return the number of bytes written on success, -1 on error. */
584 rmt_write__ (int handle, char *buffer, size_t length)
586 char command_buffer[COMMAND_BUFFER_SIZE];
587 RETSIGTYPE (*pipe_handler) ();
590 sprintf (command_buffer, "W%lu\n", (unsigned long) length);
591 if (do_command (handle, command_buffer) == -1)
594 pipe_handler = signal (SIGPIPE, SIG_IGN);
595 written = full_write (WRITE_SIDE (handle), buffer, length);
596 signal (SIGPIPE, pipe_handler);
597 if (written == length)
598 return get_status (handle);
602 _rmt_shutdown (handle, EIO);
606 /* Perform an imitation lseek operation on remote tape connection
607 HANDLE. Return the new file offset if successful, -1 if on error. */
609 rmt_lseek__ (int handle, off_t offset, int whence)
611 char command_buffer[COMMAND_BUFFER_SIZE];
612 char operand_buffer[UINTMAX_STRSIZE_BOUND];
613 uintmax_t u = offset < 0 ? - (uintmax_t) offset : (uintmax_t) offset;
614 char *p = operand_buffer + sizeof operand_buffer;
617 *--p = '0' + (int) (u % 10);
618 while ((u /= 10) != 0);
624 case SEEK_SET: whence = 0; break;
625 case SEEK_CUR: whence = 1; break;
626 case SEEK_END: whence = 2; break;
630 sprintf (command_buffer, "L%s\n%d\n", p, whence);
632 if (do_command (handle, command_buffer) == -1)
635 return get_status_off (handle);
638 /* Perform a raw tape operation on remote tape connection HANDLE.
639 Return the results of the ioctl, or -1 on error. */
641 rmt_ioctl__ (int handle, int operation, char *argument)
652 char command_buffer[COMMAND_BUFFER_SIZE];
653 char operand_buffer[UINTMAX_STRSIZE_BOUND];
654 uintmax_t u = (((struct mtop *) argument)->mt_count < 0
655 ? - (uintmax_t) ((struct mtop *) argument)->mt_count
656 : (uintmax_t) ((struct mtop *) argument)->mt_count);
657 char *p = operand_buffer + sizeof operand_buffer;
660 *--p = '0' + (int) (u % 10);
661 while ((u /= 10) != 0);
662 if (((struct mtop *) argument)->mt_count < 0)
665 /* MTIOCTOP is the easy one. Nothing is transferred in binary. */
667 sprintf (command_buffer, "I%d\n%s\n",
668 ((struct mtop *) argument)->mt_op, p);
669 if (do_command (handle, command_buffer) == -1)
672 return get_status (handle);
674 #endif /* MTIOCTOP */
682 /* Grab the status and read it directly into the structure. This
683 assumes that the status buffer is not padded and that 2 shorts
684 fit in a long without any word alignment problems; i.e., the
685 whole struct is contiguous. NOTE - this is probably NOT a good
688 if (do_command (handle, "S") == -1
689 || (status = get_status (handle), status == -1))
692 for (; status > 0; status -= counter, argument += counter)
694 counter = safe_read (READ_SIDE (handle), argument, status);
697 _rmt_shutdown (handle, EIO);
702 /* Check for byte position. mt_type (or mt_model) is a small integer
703 field (normally) so we will check its magnitude. If it is larger
704 than 256, we will assume that the bytes are swapped and go through
705 and reverse all the bytes. */
707 if (((struct mtget *) argument)->MTIO_CHECK_FIELD < 256)
710 for (counter = 0; counter < status; counter += 2)
712 char copy = argument[counter];
714 argument[counter] = argument[counter + 1];
715 argument[counter + 1] = copy;
720 #endif /* MTIOCGET */