1 /* Functions for communicating with a remote tape drive.
3 Copyright (C) 1988, 1992, 1994, 1996, 1997, 1999, 2000, 2001, 2004,
4 2005, 2006, 2007 Free Software Foundation, Inc.
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 3, 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, 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. */
36 #include "system-ioctl.h"
38 #include <safe-read.h>
39 #include <full-write.h>
41 /* Try hard to get EOPNOTSUPP defined. 486/ISC has it in net/errno.h,
42 3B2/SVR3 has it in sys/inet.h. Otherwise, like on MSDOS, use EINVAL. */
46 # include <net/errno.h>
49 # include <sys/inet.h>
52 # define EOPNOTSUPP EINVAL
63 #include <rmt-command.h>
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 char *rmt_command = DEFAULT_RMT_COMMAND;
95 /* Temporary variable used by macros in rmt.h. */
98 /* If true, always consider file names to be local, even if they contain
100 bool force_local_option;
104 /* Close remote tape connection HANDLE, and reset errno to ERRNO_VALUE. */
106 _rmt_shutdown (int handle, int errno_value)
108 close (READ_SIDE (handle));
109 close (WRITE_SIDE (handle));
110 READ_SIDE (handle) = -1;
111 WRITE_SIDE (handle) = -1;
115 /* Attempt to perform the remote tape command specified in BUFFER on
116 remote tape connection HANDLE. Return 0 if successful, -1 on
119 do_command (int handle, const char *buffer)
121 /* Save the current pipe handler and try to make the request. */
123 size_t length = strlen (buffer);
124 RETSIGTYPE (*pipe_handler) (int) = signal (SIGPIPE, SIG_IGN);
125 ssize_t written = full_write (WRITE_SIDE (handle), buffer, length);
126 signal (SIGPIPE, pipe_handler);
128 if (written == length)
131 /* Something went wrong. Close down and go home. */
133 _rmt_shutdown (handle, EIO);
138 get_status_string (int handle, char *command_buffer)
143 /* Read the reply command line. */
145 for (counter = 0, cursor = command_buffer;
146 counter < COMMAND_BUFFER_SIZE;
149 if (safe_read (READ_SIDE (handle), cursor, 1) != 1)
151 _rmt_shutdown (handle, EIO);
161 if (counter == COMMAND_BUFFER_SIZE)
163 _rmt_shutdown (handle, EIO);
167 /* Check the return status. */
169 for (cursor = command_buffer; *cursor; cursor++)
173 if (*cursor == 'E' || *cursor == 'F')
175 /* Skip the error message line. */
177 /* FIXME: there is better to do than merely ignoring error messages
178 coming from the remote end. Translate them, too... */
183 while (safe_read (READ_SIDE (handle), &character, 1) == 1)
184 if (character == '\n')
188 errno = atoi (cursor + 1);
191 _rmt_shutdown (handle, errno);
196 /* Check for mis-synced pipes. */
200 _rmt_shutdown (handle, EIO);
204 /* Got an `A' (success) response. */
209 /* Read and return the status from remote tape connection HANDLE. If
210 an error occurred, return -1 and set errno. */
212 get_status (int handle)
214 char command_buffer[COMMAND_BUFFER_SIZE];
215 const char *status = get_status_string (handle, command_buffer);
218 long int result = atol (status);
227 get_status_off (int handle)
229 char command_buffer[COMMAND_BUFFER_SIZE];
230 const char *status = get_status_string (handle, command_buffer);
236 /* Parse status, taking care to check for overflow.
237 We can't use standard functions,
238 since off_t might be longer than long. */
243 for (; *status == ' ' || *status == '\t'; status++)
246 negative = *status == '-';
247 status += negative || *status == '+';
251 int digit = *status++ - '0';
252 if (9 < (unsigned) digit)
256 off_t c10 = 10 * count;
257 off_t nc = negative ? c10 - digit : c10 + digit;
258 if (c10 / 10 != count || (negative ? c10 < nc : nc < c10))
270 /* Execute /etc/rmt as user USER on remote system HOST using rexec.
271 Return a file descriptor of a bidirectional socket for stdin and
272 stdout. If USER is zero, use the current username.
274 By default, this code is not used, since it requires that the user
275 have a .netrc file in his/her home directory, or that the
276 application designer be willing to have rexec prompt for login and
277 password info. This may be unacceptable, and .rhosts files for use
278 with rsh are much more common on BSD systems. */
280 _rmt_rexec (char *host, char *user)
282 int saved_stdin = dup (STDIN_FILENO);
283 int saved_stdout = dup (STDOUT_FILENO);
284 struct servent *rexecserv;
287 /* When using cpio -o < filename, stdin is no longer the tty. But the
288 rexec subroutine reads the login and the passwd on stdin, to allow
289 remote execution of the command. So, reopen stdin and stdout on
290 /dev/tty before the rexec and give them back their original value
293 if (! freopen ("/dev/tty", "r", stdin))
294 freopen ("/dev/null", "r", stdin);
295 if (! freopen ("/dev/tty", "w", stdout))
296 freopen ("/dev/null", "w", stdout);
298 if (rexecserv = getservbyname ("exec", "tcp"), !rexecserv)
299 error (EXIT_ON_EXEC_ERROR, 0, _("exec/tcp: Service not available"));
301 result = rexec (&host, rexecserv->s_port, user, 0, rmt_command, 0);
302 if (fclose (stdin) == EOF)
303 error (0, errno, _("stdin"));
304 fdopen (saved_stdin, "r");
305 if (fclose (stdout) == EOF)
306 error (0, errno, _("stdout"));
307 fdopen (saved_stdout, "w");
312 #endif /* WITH_REXEC */
314 /* Place into BUF a string representing OFLAG, which must be suitable
315 as argument 2 of `open'. BUF must be large enough to hold the
316 result. This function should generate a string that decode_oflag
319 encode_oflag (char *buf, int oflag)
321 sprintf (buf, "%d ", oflag);
323 switch (oflag & O_ACCMODE)
325 case O_RDONLY: strcat (buf, "O_RDONLY"); break;
326 case O_RDWR: strcat (buf, "O_RDWR"); break;
327 case O_WRONLY: strcat (buf, "O_WRONLY"); break;
332 if (oflag & O_APPEND) strcat (buf, "|O_APPEND");
334 if (oflag & O_CREAT) strcat (buf, "|O_CREAT");
336 if (oflag & O_DSYNC) strcat (buf, "|O_DSYNC");
338 if (oflag & O_EXCL) strcat (buf, "|O_EXCL");
340 if (oflag & O_LARGEFILE) strcat (buf, "|O_LARGEFILE");
343 if (oflag & O_NOCTTY) strcat (buf, "|O_NOCTTY");
345 if (oflag & O_NONBLOCK) strcat (buf, "|O_NONBLOCK");
347 if (oflag & O_RSYNC) strcat (buf, "|O_RSYNC");
350 if (oflag & O_SYNC) strcat (buf, "|O_SYNC");
352 if (oflag & O_TRUNC) strcat (buf, "|O_TRUNC");
355 /* Open a file (a magnetic tape device?) on the system specified in
356 FILE_NAME, as the given user. FILE_NAME has the form `[USER@]HOST:FILE'.
357 OPEN_MODE is O_RDONLY, O_WRONLY, etc. If successful, return the
358 remote pipe number plus BIAS. REMOTE_SHELL may be overridden. On
361 rmt_open__ (const char *file_name, int open_mode, int bias,
362 const char *remote_shell)
364 int remote_pipe_number; /* pseudo, biased file descriptor */
365 char *file_name_copy; /* copy of file_name string */
366 char *remote_host; /* remote host name */
367 char *remote_file; /* remote file name (often a device) */
368 char *remote_user; /* remote user name */
370 /* Find an unused pair of file descriptors. */
372 for (remote_pipe_number = 0;
373 remote_pipe_number < MAXUNIT;
374 remote_pipe_number++)
375 if (READ_SIDE (remote_pipe_number) == -1
376 && WRITE_SIDE (remote_pipe_number) == -1)
379 if (remote_pipe_number == MAXUNIT)
385 /* Pull apart the system and device, and optional user. */
390 file_name_copy = xstrdup (file_name);
391 remote_host = file_name_copy;
395 for (cursor = file_name_copy; *cursor; cursor++)
402 /* Do not allow newlines in the file_name, since the protocol
403 uses newline delimiters. */
404 free (file_name_copy);
411 remote_user = remote_host;
413 remote_host = cursor + 1;
421 remote_file = cursor + 1;
427 /* FIXME: Should somewhat validate the decoding, here. */
428 if (gethostbyname (remote_host) == NULL)
429 error (EXIT_ON_EXEC_ERROR, 0, _("Cannot connect to %s: resolve failed"),
432 if (remote_user && *remote_user == '\0')
437 /* Execute the remote command using rexec. */
439 READ_SIDE (remote_pipe_number) = _rmt_rexec (remote_host, remote_user);
440 if (READ_SIDE (remote_pipe_number) < 0)
443 free (file_name_copy);
448 WRITE_SIDE (remote_pipe_number) = READ_SIDE (remote_pipe_number);
450 #else /* not WITH_REXEC */
452 const char *remote_shell_basename;
455 /* Identify the remote command to be executed. */
460 remote_shell = REMOTE_SHELL;
462 free (file_name_copy);
467 remote_shell_basename = last_component (remote_shell);
469 /* Set up the pipes for the `rsh' command, and fork. */
471 if (pipe (to_remote[remote_pipe_number]) == -1
472 || pipe (from_remote[remote_pipe_number]) == -1)
475 free (file_name_copy);
484 free (file_name_copy);
493 close (STDIN_FILENO);
494 dup (to_remote[remote_pipe_number][PREAD]);
495 close (to_remote[remote_pipe_number][PREAD]);
496 close (to_remote[remote_pipe_number][PWRITE]);
498 close (STDOUT_FILENO);
499 dup (from_remote[remote_pipe_number][PWRITE]);
500 close (from_remote[remote_pipe_number][PREAD]);
501 close (from_remote[remote_pipe_number][PWRITE]);
503 sys_reset_uid_gid ();
506 execl (remote_shell, remote_shell_basename, remote_host,
507 "-l", remote_user, rmt_command, (char *) 0);
509 execl (remote_shell, remote_shell_basename, remote_host,
510 rmt_command, (char *) 0);
512 /* Bad problems if we get here. */
514 /* In a previous version, _exit was used here instead of exit. */
515 error (EXIT_ON_EXEC_ERROR, errno, _("Cannot execute remote shell"));
520 close (from_remote[remote_pipe_number][PWRITE]);
521 close (to_remote[remote_pipe_number][PREAD]);
523 #endif /* not WITH_REXEC */
525 /* Attempt to open the tape device. */
528 size_t remote_file_len = strlen (remote_file);
529 char *command_buffer = xmalloc (remote_file_len + 1000);
530 sprintf (command_buffer, "O%s\n", remote_file);
531 encode_oflag (command_buffer + remote_file_len + 2, open_mode);
532 strcat (command_buffer, "\n");
533 if (do_command (remote_pipe_number, command_buffer) == -1
534 || get_status (remote_pipe_number) == -1)
537 free (command_buffer);
538 free (file_name_copy);
539 _rmt_shutdown (remote_pipe_number, e);
542 free (command_buffer);
545 free (file_name_copy);
546 return remote_pipe_number + bias;
549 /* Close remote tape connection HANDLE and shut down. Return 0 if
550 successful, -1 on error. */
552 rmt_close__ (int handle)
556 if (do_command (handle, "C\n") == -1)
559 status = get_status (handle);
560 _rmt_shutdown (handle, errno);
564 /* Read up to LENGTH bytes into BUFFER from remote tape connection HANDLE.
565 Return the number of bytes read on success, SAFE_READ_ERROR on error. */
567 rmt_read__ (int handle, char *buffer, size_t length)
569 char command_buffer[COMMAND_BUFFER_SIZE];
574 sprintf (command_buffer, "R%lu\n", (unsigned long) length);
575 if (do_command (handle, command_buffer) == -1
576 || (status = get_status (handle)) == SAFE_READ_ERROR
578 return SAFE_READ_ERROR;
580 for (counter = 0; counter < status; counter += rlen, buffer += rlen)
582 rlen = safe_read (READ_SIDE (handle), buffer, status - counter);
583 if (rlen == SAFE_READ_ERROR || rlen == 0)
585 _rmt_shutdown (handle, EIO);
586 return SAFE_READ_ERROR;
593 /* Write LENGTH bytes from BUFFER to remote tape connection HANDLE.
594 Return the number of bytes written. */
596 rmt_write__ (int handle, char *buffer, size_t length)
598 char command_buffer[COMMAND_BUFFER_SIZE];
599 RETSIGTYPE (*pipe_handler) (int);
602 sprintf (command_buffer, "W%lu\n", (unsigned long) length);
603 if (do_command (handle, command_buffer) == -1)
606 pipe_handler = signal (SIGPIPE, SIG_IGN);
607 written = full_write (WRITE_SIDE (handle), buffer, length);
608 signal (SIGPIPE, pipe_handler);
609 if (written == length)
611 long int r = get_status (handle);
621 _rmt_shutdown (handle, EIO);
625 /* Perform an imitation lseek operation on remote tape connection
626 HANDLE. Return the new file offset if successful, -1 if on error. */
628 rmt_lseek__ (int handle, off_t offset, int whence)
630 char command_buffer[COMMAND_BUFFER_SIZE];
631 char operand_buffer[UINTMAX_STRSIZE_BOUND];
632 uintmax_t u = offset < 0 ? - (uintmax_t) offset : (uintmax_t) offset;
633 char *p = operand_buffer + sizeof operand_buffer;
637 *--p = '0' + (int) (u % 10);
638 while ((u /= 10) != 0);
644 case SEEK_SET: whence = 0; break;
645 case SEEK_CUR: whence = 1; break;
646 case SEEK_END: whence = 2; break;
650 sprintf (command_buffer, "L%s\n%d\n", p, whence);
652 if (do_command (handle, command_buffer) == -1)
655 return get_status_off (handle);
658 /* Perform a raw tape operation on remote tape connection HANDLE.
659 Return the results of the ioctl, or -1 on error. */
661 rmt_ioctl__ (int handle, int operation, char *argument)
672 char command_buffer[COMMAND_BUFFER_SIZE];
673 char operand_buffer[UINTMAX_STRSIZE_BOUND];
674 uintmax_t u = (((struct mtop *) argument)->mt_count < 0
675 ? - (uintmax_t) ((struct mtop *) argument)->mt_count
676 : (uintmax_t) ((struct mtop *) argument)->mt_count);
677 char *p = operand_buffer + sizeof operand_buffer;
681 *--p = '0' + (int) (u % 10);
682 while ((u /= 10) != 0);
683 if (((struct mtop *) argument)->mt_count < 0)
686 /* MTIOCTOP is the easy one. Nothing is transferred in binary. */
688 sprintf (command_buffer, "I%d\n%s\n",
689 ((struct mtop *) argument)->mt_op, p);
690 if (do_command (handle, command_buffer) == -1)
693 return get_status (handle);
695 #endif /* MTIOCTOP */
703 /* Grab the status and read it directly into the structure. This
704 assumes that the status buffer is not padded and that 2 shorts
705 fit in a long without any word alignment problems; i.e., the
706 whole struct is contiguous. NOTE - this is probably NOT a good
709 if (do_command (handle, "S") == -1
710 || (status = get_status (handle), status == -1))
713 if (status > sizeof (struct mtop))
719 for (; status > 0; status -= counter, argument += counter)
721 counter = safe_read (READ_SIDE (handle), argument, status);
722 if (counter == SAFE_READ_ERROR || counter == 0)
724 _rmt_shutdown (handle, EIO);
729 /* Check for byte position. mt_type (or mt_model) is a small integer
730 field (normally) so we will check its magnitude. If it is larger
731 than 256, we will assume that the bytes are swapped and go through
732 and reverse all the bytes. */
734 if (((struct mtget *) argument)->MTIO_CHECK_FIELD < 256)
737 for (counter = 0; counter < status; counter += 2)
739 char copy = argument[counter];
741 argument[counter] = argument[counter + 1];
742 argument[counter + 1] = copy;
747 #endif /* MTIOCGET */