]> Dogcows Code - chaz/tar/blob - src/rtapelib.c
(read_and): Invoke apply_nonancestor_delayed_set_stat on file names
[chaz/tar] / src / rtapelib.c
1 /* Functions for communicating with a remote tape drive.
2 Copyright 1988, 1992, 1994, 1996, 1997, 1999 Free Software Foundation, Inc.
3
4 This program is free software; you can redistribute it and/or modify
5 it under the terms of the GNU General Public License as published by
6 the Free Software Foundation; either version 2, or (at your option)
7 any later version.
8
9 This program is distributed in the hope that it will be useful,
10 but WITHOUT ANY WARRANTY; without even the implied warranty of
11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 GNU General Public License for more details.
13
14 You should have received a copy of the GNU General Public License
15 along with this program; if not, write to the Free Software Foundation,
16 Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
17
18 /* The man page rmt(8) for /etc/rmt documents the remote mag tape protocol
19 which rdump and rrestore use. Unfortunately, the man page is *WRONG*.
20 The author of the routines I'm including originally wrote his code just
21 based on the man page, and it didn't work, so he went to the rdump source
22 to figure out why. The only thing he had to change was to check for the
23 'F' return code in addition to the 'E', and to separate the various
24 arguments with \n instead of a space. I personally don't think that this
25 is much of a problem, but I wanted to point it out. -- Arnold Robbins
26
27 Originally written by Jeff Lee, modified some by Arnold Robbins. Redone
28 as a library that can replace open, read, write, etc., by Fred Fish, with
29 some additional work by Arnold Robbins. Modified to make all rmt* calls
30 into macros for speed by Jay Fenlason. Use -DWITH_REXEC for rexec
31 code, courtesy of Dan Kegel. */
32
33 #include "system.h"
34
35 #include "basename.h"
36 #include "safe-read.h"
37
38 /* Try hard to get EOPNOTSUPP defined. 486/ISC has it in net/errno.h,
39 3B2/SVR3 has it in sys/inet.h. Otherwise, like on MSDOS, use EINVAL. */
40
41 #ifndef EOPNOTSUPP
42 # if HAVE_NET_ERRNO_H
43 # include <net/errno.h>
44 # endif
45 # if HAVE_SYS_INET_H
46 # include <sys/inet.h>
47 # endif
48 # ifndef EOPNOTSUPP
49 # define EOPNOTSUPP EINVAL
50 # endif
51 #endif
52
53 #include <signal.h>
54
55 #if HAVE_NETDB_H
56 # include <netdb.h>
57 #endif
58
59 #include "rmt.h"
60
61 /* FIXME: Just to shut up -Wall. */
62 int rexec ();
63
64 /* Exit status if exec errors. */
65 #define EXIT_ON_EXEC_ERROR 128
66
67 /* FIXME: Size of buffers for reading and writing commands to rmt. */
68 #define COMMAND_BUFFER_SIZE 64
69
70 #ifndef RETSIGTYPE
71 # define RETSIGTYPE void
72 #endif
73
74 /* FIXME: Maximum number of simultaneous remote tape connections. */
75 #define MAXUNIT 4
76
77 #define PREAD 0 /* read file descriptor from pipe() */
78 #define PWRITE 1 /* write file descriptor from pipe() */
79
80 /* Return the parent's read side of remote tape connection Fd. */
81 #define READ_SIDE(Fd) (from_remote[Fd][PREAD])
82
83 /* Return the parent's write side of remote tape connection Fd. */
84 #define WRITE_SIDE(Fd) (to_remote[Fd][PWRITE])
85
86 /* The pipes for receiving data from remote tape drives. */
87 static int from_remote[MAXUNIT][2] = {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}};
88
89 /* The pipes for sending data to remote tape drives. */
90 static int to_remote[MAXUNIT][2] = {{-1, -1}, {-1, -1}, {-1, -1}, {-1, -1}};
91
92 /* Temporary variable used by macros in rmt.h. */
93 char *rmt_path__;
94 \f
95
96 /*----------------------------------------------------------------------.
97 | Close remote tape connection HANDLE, and reset errno to ERRNO_VALUE. |
98 `----------------------------------------------------------------------*/
99
100 static void
101 _rmt_shutdown (int handle, int errno_value)
102 {
103 close (READ_SIDE (handle));
104 close (WRITE_SIDE (handle));
105 READ_SIDE (handle) = -1;
106 WRITE_SIDE (handle) = -1;
107 errno = errno_value;
108 }
109
110 /*-------------------------------------------------------------------------.
111 | Attempt to perform the remote tape command specified in BUFFER on remote |
112 | tape connection HANDLE. Return 0 if successful, -1 on error. |
113 `-------------------------------------------------------------------------*/
114
115 static int
116 do_command (int handle, const char *buffer)
117 {
118 size_t length;
119 RETSIGTYPE (*pipe_handler) ();
120
121 /* Save the current pipe handler and try to make the request. */
122
123 pipe_handler = signal (SIGPIPE, SIG_IGN);
124 length = strlen (buffer);
125 if (full_write (WRITE_SIDE (handle), buffer, length) == length)
126 {
127 signal (SIGPIPE, pipe_handler);
128 return 0;
129 }
130
131 /* Something went wrong. Close down and go home. */
132
133 signal (SIGPIPE, pipe_handler);
134 _rmt_shutdown (handle, EIO);
135 return -1;
136 }
137
138 static char *
139 get_status_string (int handle, char *command_buffer)
140 {
141 char *cursor;
142 int counter;
143
144 /* Read the reply command line. */
145
146 for (counter = 0, cursor = command_buffer;
147 counter < COMMAND_BUFFER_SIZE;
148 counter++, cursor++)
149 {
150 if (safe_read (READ_SIDE (handle), cursor, 1) != 1)
151 {
152 _rmt_shutdown (handle, EIO);
153 return 0;
154 }
155 if (*cursor == '\n')
156 {
157 *cursor = '\0';
158 break;
159 }
160 }
161
162 if (counter == COMMAND_BUFFER_SIZE)
163 {
164 _rmt_shutdown (handle, EIO);
165 return 0;
166 }
167
168 /* Check the return status. */
169
170 for (cursor = command_buffer; *cursor; cursor++)
171 if (*cursor != ' ')
172 break;
173
174 if (*cursor == 'E' || *cursor == 'F')
175 {
176 errno = atoi (cursor + 1);
177
178 /* Skip the error message line. */
179
180 /* FIXME: there is better to do than merely ignoring error messages
181 coming from the remote end. Translate them, too... */
182
183 {
184 char character;
185
186 while (safe_read (READ_SIDE (handle), &character, 1) == 1)
187 if (character == '\n')
188 break;
189 }
190
191 if (*cursor == 'F')
192 _rmt_shutdown (handle, errno);
193
194 return 0;
195 }
196
197 /* Check for mis-synced pipes. */
198
199 if (*cursor != 'A')
200 {
201 _rmt_shutdown (handle, EIO);
202 return 0;
203 }
204
205 /* Got an `A' (success) response. */
206
207 return cursor + 1;
208 }
209
210 /*----------------------------------------------------------------------.
211 | Read and return the status from remote tape connection HANDLE. If an |
212 | error occurred, return -1 and set errno. |
213 `----------------------------------------------------------------------*/
214
215 static long
216 get_status (int handle)
217 {
218 char command_buffer[COMMAND_BUFFER_SIZE];
219 const char *status = get_status_string (handle, command_buffer);
220 return status ? atol (status) : -1L;
221 }
222
223 static off_t
224 get_status_off (int handle)
225 {
226 char command_buffer[COMMAND_BUFFER_SIZE];
227 const char *status = get_status_string (handle, command_buffer);
228
229 if (! status)
230 return -1;
231 else
232 {
233 /* Parse status, taking care to check for overflow.
234 We can't use standard functions,
235 since off_t might be longer than long. */
236
237 off_t count = 0;
238 int negative;
239
240 for (; *status == ' ' || *status == '\t'; status++)
241 continue;
242
243 negative = *status == '-';
244 status += negative || *status == '+';
245
246 for (;;)
247 {
248 int digit = *status++ - '0';
249 if (9 < (unsigned) digit)
250 break;
251 else
252 {
253 off_t c10 = 10 * count;
254 off_t nc = negative ? c10 - digit : c10 + digit;
255 if (c10 / 10 != count || (negative ? c10 < nc : nc < c10))
256 return -1;
257 count = nc;
258 }
259 }
260
261 return count;
262 }
263 }
264
265 #if WITH_REXEC
266
267 /*-------------------------------------------------------------------------.
268 | Execute /etc/rmt as user USER on remote system HOST using rexec. Return |
269 | a file descriptor of a bidirectional socket for stdin and stdout. If |
270 | USER is zero, use the current username. |
271 | |
272 | By default, this code is not used, since it requires that the user have |
273 | a .netrc file in his/her home directory, or that the application |
274 | designer be willing to have rexec prompt for login and password info. |
275 | This may be unacceptable, and .rhosts files for use with rsh are much |
276 | more common on BSD systems. |
277 `-------------------------------------------------------------------------*/
278
279 static int
280 _rmt_rexec (char *host, char *user)
281 {
282 int saved_stdin = dup (STDIN_FILENO);
283 int saved_stdout = dup (STDOUT_FILENO);
284 struct servent *rexecserv;
285 int result;
286
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
291 after. */
292
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);
297
298 if (rexecserv = getservbyname ("exec", "tcp"), !rexecserv)
299 error (EXIT_ON_EXEC_ERROR, 0, _("exec/tcp: Service not available"));
300
301 result = rexec (&host, rexecserv->s_port, user, 0, "/etc/rmt", 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");
308
309 return result;
310 }
311
312 #endif /* WITH_REXEC */
313
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
317 can parse. */
318 static void
319 encode_oflag (char *buf, int oflag)
320 {
321 sprintf (buf, "%d ", oflag);
322
323 switch (oflag & O_ACCMODE)
324 {
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;
328 default: abort ();
329 }
330
331 #ifdef O_APPEND
332 if (oflag & O_APPEND) strcat (buf, "|O_APPEND");
333 #endif
334 if (oflag & O_CREAT) strcat (buf, "|O_CREAT");
335 #ifdef O_DSYNC
336 if (oflag & O_DSYNC) strcat (buf, "|O_DSYNC");
337 #endif
338 if (oflag & O_EXCL) strcat (buf, "|O_EXCL");
339 #ifdef O_LARGEFILE
340 if (oflag & O_LARGEFILE) strcat (buf, "|O_LARGEFILE");
341 #endif
342 #ifdef O_NOCTTY
343 if (oflag & O_NOCTTY) strcat (buf, "|O_NOCTTY");
344 #endif
345 #ifdef O_NONBLOCK
346 if (oflag & O_NONBLOCK) strcat (buf, "|O_NONBLOCK");
347 #endif
348 #ifdef O_RSYNC
349 if (oflag & O_RSYNC) strcat (buf, "|O_RSYNC");
350 #endif
351 #ifdef O_SYNC
352 if (oflag & O_SYNC) strcat (buf, "|O_SYNC");
353 #endif
354 if (oflag & O_TRUNC) strcat (buf, "|O_TRUNC");
355 }
356
357 /*------------------------------------------------------------------------.
358 | Open a file (a magnetic tape device?) on the system specified in PATH, |
359 | as the given user. PATH has the form `[USER@]HOST:FILE'. OPEN_MODE is |
360 | O_RDONLY, O_WRONLY, etc. If successful, return the remote pipe number |
361 | plus BIAS. REMOTE_SHELL may be overridden. On error, return -1. |
362 `------------------------------------------------------------------------*/
363
364 int
365 rmt_open__ (const char *path, int open_mode, int bias, const char *remote_shell)
366 {
367 int remote_pipe_number; /* pseudo, biased file descriptor */
368 char *path_copy ; /* copy of path string */
369 char *remote_host; /* remote host name */
370 char *remote_file; /* remote file name (often a device) */
371 char *remote_user; /* remote user name */
372
373 /* Find an unused pair of file descriptors. */
374
375 for (remote_pipe_number = 0;
376 remote_pipe_number < MAXUNIT;
377 remote_pipe_number++)
378 if (READ_SIDE (remote_pipe_number) == -1
379 && WRITE_SIDE (remote_pipe_number) == -1)
380 break;
381
382 if (remote_pipe_number == MAXUNIT)
383 {
384 errno = EMFILE;
385 return -1;
386 }
387
388 /* Pull apart the system and device, and optional user. */
389
390 {
391 char *cursor;
392
393 path_copy = xstrdup (path);
394 remote_host = path_copy;
395 remote_user = 0;
396 remote_file = 0;
397
398 for (cursor = path_copy; *cursor; cursor++)
399 switch (*cursor)
400 {
401 default:
402 break;
403
404 case '\n':
405 /* Do not allow newlines in the path, since the protocol
406 uses newline delimiters. */
407 free (path_copy);
408 errno = ENOENT;
409 return -1;
410
411 case '@':
412 if (!remote_user)
413 {
414 remote_user = remote_host;
415 *cursor = '\0';
416 remote_host = cursor + 1;
417 }
418 break;
419
420 case ':':
421 if (!remote_file)
422 {
423 *cursor = '\0';
424 remote_file = cursor + 1;
425 }
426 break;
427 }
428 }
429
430 /* FIXME: Should somewhat validate the decoding, here. */
431
432 if (remote_user && *remote_user == '\0')
433 remote_user = 0;
434
435 #if WITH_REXEC
436
437 /* Execute the remote command using rexec. */
438
439 READ_SIDE (remote_pipe_number) = _rmt_rexec (remote_host, remote_user);
440 if (READ_SIDE (remote_pipe_number) < 0)
441 {
442 int e = errno;
443 free (path_copy);
444 errno = e;
445 return -1;
446 }
447
448 WRITE_SIDE (remote_pipe_number) = READ_SIDE (remote_pipe_number);
449
450 #else /* not WITH_REXEC */
451 {
452 const char *remote_shell_basename;
453 pid_t status;
454
455 /* Identify the remote command to be executed. */
456
457 if (!remote_shell)
458 {
459 #ifdef REMOTE_SHELL
460 remote_shell = REMOTE_SHELL;
461 #else
462 free (path_copy);
463 errno = EIO;
464 return -1;
465 #endif
466 }
467 remote_shell_basename = base_name (remote_shell);
468
469 /* Set up the pipes for the `rsh' command, and fork. */
470
471 if (pipe (to_remote[remote_pipe_number]) == -1
472 || pipe (from_remote[remote_pipe_number]) == -1)
473 {
474 int e = errno;
475 free (path_copy);
476 errno = e;
477 return -1;
478 }
479
480 status = fork ();
481 if (status == -1)
482 {
483 int e = errno;
484 free (path_copy);
485 errno = e;
486 return -1;
487 }
488
489 if (status == 0)
490 {
491 /* Child. */
492
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]);
497
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]);
502
503 #if !MSDOS
504 setuid (getuid ());
505 setgid (getgid ());
506 #endif
507
508 if (remote_user)
509 execl (remote_shell, remote_shell_basename, remote_host,
510 "-l", remote_user, "/etc/rmt", (char *) 0);
511 else
512 execl (remote_shell, remote_shell_basename, remote_host,
513 "/etc/rmt", (char *) 0);
514
515 /* Bad problems if we get here. */
516
517 /* In a previous version, _exit was used here instead of exit. */
518 error (EXIT_ON_EXEC_ERROR, errno, _("Cannot execute remote shell"));
519 }
520
521 /* Parent. */
522
523 close (from_remote[remote_pipe_number][PWRITE]);
524 close (to_remote[remote_pipe_number][PREAD]);
525 }
526 #endif /* not WITH_REXEC */
527
528 /* Attempt to open the tape device. */
529
530 {
531 size_t remote_file_len = strlen (remote_file);
532 char *command_buffer = xmalloc (remote_file_len + 1000);
533 sprintf (command_buffer, "O%s\n", remote_file);
534 encode_oflag (command_buffer + remote_file_len + 2, open_mode);
535 strcat (command_buffer, "\n");
536 if (do_command (remote_pipe_number, command_buffer) == -1
537 || get_status (remote_pipe_number) == -1)
538 {
539 int e = errno;
540 free (command_buffer);
541 free (path_copy);
542 _rmt_shutdown (remote_pipe_number, e);
543 return -1;
544 }
545 free (command_buffer);
546 }
547
548 free (path_copy);
549 return remote_pipe_number + bias;
550 }
551
552 /*----------------------------------------------------------------.
553 | Close remote tape connection HANDLE and shut down. Return 0 if |
554 | successful, -1 on error. |
555 `----------------------------------------------------------------*/
556
557 int
558 rmt_close__ (int handle)
559 {
560 int status;
561
562 if (do_command (handle, "C\n") == -1)
563 return -1;
564
565 status = get_status (handle);
566 _rmt_shutdown (handle, errno);
567 return status;
568 }
569
570 /*-------------------------------------------------------------------------.
571 | Read up to LENGTH bytes into BUFFER from remote tape connection HANDLE. |
572 | Return the number of bytes read on success, -1 on error. |
573 `-------------------------------------------------------------------------*/
574
575 ssize_t
576 rmt_read__ (int handle, char *buffer, size_t length)
577 {
578 char command_buffer[COMMAND_BUFFER_SIZE];
579 ssize_t status, rlen;
580 size_t counter;
581
582 sprintf (command_buffer, "R%lu\n", (unsigned long) length);
583 if (do_command (handle, command_buffer) == -1
584 || (status = get_status (handle)) == -1)
585 return -1;
586
587 for (counter = 0; counter < status; counter += rlen, buffer += rlen)
588 {
589 rlen = safe_read (READ_SIDE (handle), buffer, status - counter);
590 if (rlen <= 0)
591 {
592 _rmt_shutdown (handle, EIO);
593 return -1;
594 }
595 }
596
597 return status;
598 }
599
600 /*-------------------------------------------------------------------------.
601 | Write LENGTH bytes from BUFFER to remote tape connection HANDLE. Return |
602 | the number of bytes written on success, -1 on error. |
603 `-------------------------------------------------------------------------*/
604
605 ssize_t
606 rmt_write__ (int handle, char *buffer, size_t length)
607 {
608 char command_buffer[COMMAND_BUFFER_SIZE];
609 RETSIGTYPE (*pipe_handler) ();
610
611 sprintf (command_buffer, "W%lu\n", (unsigned long) length);
612 if (do_command (handle, command_buffer) == -1)
613 return -1;
614
615 pipe_handler = signal (SIGPIPE, SIG_IGN);
616 if (full_write (WRITE_SIDE (handle), buffer, length) == length)
617 {
618 signal (SIGPIPE, pipe_handler);
619 return get_status (handle);
620 }
621
622 /* Write error. */
623
624 signal (SIGPIPE, pipe_handler);
625 _rmt_shutdown (handle, EIO);
626 return -1;
627 }
628
629 /*------------------------------------------------------------------------.
630 | Perform an imitation lseek operation on remote tape connection HANDLE. |
631 | Return the new file offset if successful, -1 if on error. |
632 `------------------------------------------------------------------------*/
633
634 off_t
635 rmt_lseek__ (int handle, off_t offset, int whence)
636 {
637 char command_buffer[COMMAND_BUFFER_SIZE];
638 char operand_buffer[UINTMAX_STRSIZE_BOUND];
639 uintmax_t u = offset < 0 ? - (uintmax_t) offset : (uintmax_t) offset;
640 char *p = operand_buffer + sizeof operand_buffer;
641
642 do
643 *--p = '0' + (int) (u % 10);
644 while ((u /= 10) != 0);
645 if (offset < 0)
646 *--p = '-';
647
648 switch (whence)
649 {
650 case SEEK_SET: whence = 0; break;
651 case SEEK_CUR: whence = 1; break;
652 case SEEK_END: whence = 2; break;
653 default: abort ();
654 }
655
656 sprintf (command_buffer, "L%s\n%d\n", p, whence);
657
658 if (do_command (handle, command_buffer) == -1)
659 return -1;
660
661 return get_status_off (handle);
662 }
663
664 /*-----------------------------------------------------------------------.
665 | Perform a raw tape operation on remote tape connection HANDLE. Return |
666 | the results of the ioctl, or -1 on error. |
667 `-----------------------------------------------------------------------*/
668
669 int
670 rmt_ioctl__ (int handle, int operation, char *argument)
671 {
672 switch (operation)
673 {
674 default:
675 errno = EOPNOTSUPP;
676 return -1;
677
678 #ifdef MTIOCTOP
679 case MTIOCTOP:
680 {
681 char command_buffer[COMMAND_BUFFER_SIZE];
682 char operand_buffer[UINTMAX_STRSIZE_BOUND];
683 uintmax_t u = (((struct mtop *) argument)->mt_count < 0
684 ? - (uintmax_t) ((struct mtop *) argument)->mt_count
685 : (uintmax_t) ((struct mtop *) argument)->mt_count);
686 char *p = operand_buffer + sizeof operand_buffer;
687
688 do
689 *--p = '0' + (int) (u % 10);
690 while ((u /= 10) != 0);
691 if (((struct mtop *) argument)->mt_count < 0)
692 *--p = '-';
693
694 /* MTIOCTOP is the easy one. Nothing is transferred in binary. */
695
696 sprintf (command_buffer, "I%d\n%s\n",
697 ((struct mtop *) argument)->mt_op, p);
698 if (do_command (handle, command_buffer) == -1)
699 return -1;
700
701 return get_status (handle);
702 }
703 #endif /* MTIOCTOP */
704
705 #ifdef MTIOCGET
706 case MTIOCGET:
707 {
708 ssize_t status;
709 ssize_t counter;
710
711 /* Grab the status and read it directly into the structure. This
712 assumes that the status buffer is not padded and that 2 shorts
713 fit in a long without any word alignment problems; i.e., the
714 whole struct is contiguous. NOTE - this is probably NOT a good
715 assumption. */
716
717 if (do_command (handle, "S") == -1
718 || (status = get_status (handle), status == -1))
719 return -1;
720
721 for (; status > 0; status -= counter, argument += counter)
722 {
723 counter = safe_read (READ_SIDE (handle), argument, status);
724 if (counter <= 0)
725 {
726 _rmt_shutdown (handle, EIO);
727 return -1;
728 }
729 }
730
731 /* Check for byte position. mt_type (or mt_model) is a small integer
732 field (normally) so we will check its magnitude. If it is larger
733 than 256, we will assume that the bytes are swapped and go through
734 and reverse all the bytes. */
735
736 if (((struct mtget *) argument)->MTIO_CHECK_FIELD < 256)
737 return 0;
738
739 for (counter = 0; counter < status; counter += 2)
740 {
741 char copy = argument[counter];
742
743 argument[counter] = argument[counter + 1];
744 argument[counter + 1] = copy;
745 }
746
747 return 0;
748 }
749 #endif /* MTIOCGET */
750
751 }
752 }
This page took 0.065953 seconds and 4 git commands to generate.