rmtlib.c revision 1.20
1 /* $NetBSD: rmtlib.c,v 1.20 2005/12/05 02:04:16 christos Exp $ */ 2 3 /* 4 * rmt --- remote tape emulator subroutines 5 * 6 * Originally written by Jeff Lee, modified some by Arnold Robbins 7 * 8 * WARNING: The man page rmt(8) for /etc/rmt documents the remote mag 9 * tape protocol which rdump and rrestore use. Unfortunately, the man 10 * page is *WRONG*. The author of the routines I'm including originally 11 * wrote his code just based on the man page, and it didn't work, so he 12 * went to the rdump source to figure out why. The only thing he had to 13 * change was to check for the 'F' return code in addition to the 'E', 14 * and to separate the various arguments with \n instead of a space. I 15 * personally don't think that this is much of a problem, but I wanted to 16 * point it out. 17 * -- Arnold Robbins 18 * 19 * Redone as a library that can replace open, read, write, etc, by 20 * Fred Fish, with some additional work by Arnold Robbins. 21 */ 22 23 /* 24 * MAXUNIT --- Maximum number of remote tape file units 25 * 26 * READ --- Return the number of the read side file descriptor 27 * WRITE --- Return the number of the write side file descriptor 28 */ 29 30 #include <sys/cdefs.h> 31 __RCSID("$NetBSD: rmtlib.c,v 1.20 2005/12/05 02:04:16 christos Exp $"); 32 33 #define RMTIOCTL 1 34 /* #define USE_REXEC 1 */ /* rexec code courtesy of Dan Kegel, srs!dan */ 35 36 #include <sys/types.h> 37 #include <sys/stat.h> 38 39 #ifdef RMTIOCTL 40 #include <sys/ioctl.h> 41 #include <sys/mtio.h> 42 #endif 43 44 #include <assert.h> 45 #include <errno.h> 46 #include <fcntl.h> 47 #include <signal.h> 48 #include <stdarg.h> 49 #include <stdio.h> 50 #include <stdlib.h> 51 #include <string.h> 52 #include <unistd.h> 53 54 #ifdef USE_REXEC 55 #include <netdb.h> 56 #endif 57 58 #define __RMTLIB_PRIVATE 59 #include <rmt.h> /* get prototypes for remapped functions */ 60 61 #include "pathnames.h" 62 63 static int _rmt_close(int); 64 static int _rmt_ioctl(int, unsigned long, void *); 65 static off_t _rmt_lseek(int, off_t, int); 66 static int _rmt_open(const char *, int, int); 67 static ssize_t _rmt_read(int, void *, size_t); 68 static ssize_t _rmt_write(int, const void *, size_t); 69 static int command(int, char *); 70 static int remdev(const char *); 71 static void rmtabort(int); 72 static int status(int); 73 74 int isrmt(int); 75 76 77 #define BUFMAGIC 64 /* a magic number for buffer sizes */ 78 #define MAXUNIT 4 79 80 #define READ(fd) (Ctp[fd][0]) 81 #define WRITE(fd) (Ptc[fd][1]) 82 83 static int Ctp[MAXUNIT][2] = { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1} }; 84 static int Ptc[MAXUNIT][2] = { {-1, -1}, {-1, -1}, {-1, -1}, {-1, -1} }; 85 86 87 /* 88 * rmtabort --- close off a remote tape connection 89 */ 90 static void 91 rmtabort(int fildes) 92 { 93 94 close(READ(fildes)); 95 close(WRITE(fildes)); 96 READ(fildes) = -1; 97 WRITE(fildes) = -1; 98 } 99 100 101 /* 102 * command --- attempt to perform a remote tape command 103 */ 104 static int 105 command(int fildes, char *buf) 106 { 107 size_t blen; 108 void (*pstat)(int); 109 110 _DIAGASSERT(buf != NULL); 111 112 /* 113 * save current pipe status and try to make the request 114 */ 115 116 blen = strlen(buf); 117 pstat = signal(SIGPIPE, SIG_IGN); 118 if (write(WRITE(fildes), buf, blen) == blen) { 119 signal(SIGPIPE, pstat); 120 return (0); 121 } 122 123 /* 124 * something went wrong. close down and go home 125 */ 126 127 signal(SIGPIPE, pstat); 128 rmtabort(fildes); 129 130 errno = EIO; 131 return (-1); 132 } 133 134 135 /* 136 * status --- retrieve the status from the pipe 137 */ 138 static int 139 status(int fildes) 140 { 141 int i; 142 char c, *cp; 143 char buffer[BUFMAGIC]; 144 145 /* 146 * read the reply command line 147 */ 148 149 for (i = 0, cp = buffer; i < BUFMAGIC; i++, cp++) { 150 if (read(READ(fildes), cp, 1) != 1) { 151 rmtabort(fildes); 152 errno = EIO; 153 return (-1); 154 } 155 if (*cp == '\n') { 156 *cp = 0; 157 break; 158 } 159 } 160 161 if (i == BUFMAGIC) { 162 rmtabort(fildes); 163 errno = EIO; 164 return (-1); 165 } 166 167 /* 168 * check the return status 169 */ 170 171 for (cp = buffer; *cp; cp++) 172 if (*cp != ' ') 173 break; 174 175 if (*cp == 'E' || *cp == 'F') { 176 errno = atoi(cp + 1); 177 while (read(READ(fildes), &c, 1) == 1) 178 if (c == '\n') 179 break; 180 181 if (*cp == 'F') 182 rmtabort(fildes); 183 184 return (-1); 185 } 186 187 /* 188 * check for mis-synced pipes 189 */ 190 191 if (*cp != 'A') { 192 rmtabort(fildes); 193 errno = EIO; 194 return (-1); 195 } 196 197 return (atoi(cp + 1)); 198 } 199 200 201 #ifdef USE_REXEC 202 /* 203 * _rmt_rexec 204 * 205 * execute /etc/rmt on a remote system using rexec(). 206 * Return file descriptor of bidirectional socket for stdin and stdout 207 * If username is NULL, or an empty string, uses current username. 208 * 209 * ADR: By default, this code is not used, since it requires that 210 * the user have a .netrc file in his/her home directory, or that the 211 * application designer be willing to have rexec prompt for login and 212 * password info. This may be unacceptable, and .rhosts files for use 213 * with rsh are much more common on BSD systems. 214 */ 215 216 static int _rmt_rexec(const char *, const char *); 217 218 static int 219 _rmt_rexec(const char *host, const char *user) 220 { 221 struct servent *rexecserv; 222 223 _DIAGASSERT(host != NULL); 224 /* user may be NULL */ 225 226 rexecserv = getservbyname("exec", "tcp"); 227 if (rexecserv == NULL) { 228 fprintf(stderr, "? exec/tcp: service not available."); 229 exit(1); 230 } 231 if ((user != NULL) && *user == '\0') 232 user = NULL; 233 return (rexec(&host, rexecserv->s_port, user, NULL, 234 "/etc/rmt", NULL)); 235 } 236 #endif /* USE_REXEC */ 237 238 239 /* 240 * _rmt_open --- open a magtape device on system specified, as given user 241 * 242 * file name has the form [user@]system:/dev/???? 243 #ifdef COMPAT 244 * file name has the form system[.user]:/dev/???? 245 #endif 246 */ 247 248 #define MAXHOSTLEN 257 /* BSD allows very long host names... */ 249 250 static int 251 /*ARGSUSED*/ 252 _rmt_open(const char *path, int oflag, int mode) 253 { 254 int i, rc; 255 char buffer[BUFMAGIC]; 256 char host[MAXHOSTLEN]; 257 char device[BUFMAGIC]; 258 char login[BUFMAGIC]; 259 char *sys, *dev, *user; 260 261 _DIAGASSERT(path != NULL); 262 263 sys = host; 264 dev = device; 265 user = login; 266 267 /* 268 * first, find an open pair of file descriptors 269 */ 270 271 for (i = 0; i < MAXUNIT; i++) 272 if (READ(i) == -1 && WRITE(i) == -1) 273 break; 274 275 if (i == MAXUNIT) { 276 errno = EMFILE; 277 return (-1); 278 } 279 280 /* 281 * pull apart system and device, and optional user 282 * don't munge original string 283 * if COMPAT is defined, also handle old (4.2) style person.site notation. 284 */ 285 286 while (*path != '@' 287 #ifdef COMPAT 288 && *path != '.' 289 #endif 290 && *path != ':') { 291 *sys++ = *path++; 292 } 293 *sys = '\0'; 294 path++; 295 296 if (*(path - 1) == '@') { 297 (void)strncpy(user, host, sizeof(login) - 1); 298 /* saw user part of user@host */ 299 sys = host; /* start over */ 300 while (*path != ':') { 301 *sys++ = *path++; 302 } 303 *sys = '\0'; 304 path++; 305 } 306 #ifdef COMPAT 307 else if (*(path - 1) == '.') { 308 while (*path != ':') { 309 *user++ = *path++; 310 } 311 *user = '\0'; 312 path++; 313 } 314 #endif 315 else 316 *user = '\0'; 317 318 while (*path) { 319 *dev++ = *path++; 320 } 321 *dev = '\0'; 322 323 #ifdef USE_REXEC 324 /* 325 * Execute the remote command using rexec 326 */ 327 READ(i) = WRITE(i) = _rmt_rexec(host, login); 328 if (READ(i) < 0) 329 return (-1); 330 #else 331 /* 332 * setup the pipes for the 'rsh' command and fork 333 */ 334 335 if (pipe(Ptc[i]) == -1 || pipe(Ctp[i]) == -1) 336 return (-1); 337 338 if ((rc = fork()) == -1) 339 return (-1); 340 341 if (rc == 0) { 342 char *rshpath, *rsh; 343 344 close(0); 345 dup(Ptc[i][0]); 346 close(Ptc[i][0]); close(Ptc[i][1]); 347 close(1); 348 dup(Ctp[i][1]); 349 close(Ctp[i][0]); close(Ctp[i][1]); 350 (void) setuid(getuid()); 351 (void) setgid(getgid()); 352 353 if ((rshpath = getenv("RCMD_CMD")) == NULL) 354 rshpath = _PATH_RSH; 355 if ((rsh = strrchr(rshpath, '/')) == NULL) 356 rsh = rshpath; 357 else 358 rsh++; 359 360 if (*login) { 361 execl(rshpath, rsh, host, "-l", login, 362 _PATH_RMT, NULL); 363 } else { 364 execl(rshpath, rsh, host, 365 _PATH_RMT, NULL); 366 } 367 368 /* 369 * bad problems if we get here 370 */ 371 372 perror("exec"); 373 exit(1); 374 } 375 376 close(Ptc[i][0]); close(Ctp[i][1]); 377 #endif 378 379 /* 380 * now attempt to open the tape device 381 */ 382 383 (void)snprintf(buffer, sizeof(buffer), "O%s\n%d\n", device, oflag); 384 if (command(i, buffer) == -1 || status(i) == -1) 385 return (-1); 386 387 return (i); 388 } 389 390 391 /* 392 * _rmt_close --- close a remote magtape unit and shut down 393 */ 394 static int 395 _rmt_close(int fildes) 396 { 397 int rc; 398 399 if (command(fildes, "C\n") != -1) { 400 rc = status(fildes); 401 402 rmtabort(fildes); 403 return (rc); 404 } 405 406 return (-1); 407 } 408 409 410 /* 411 * _rmt_read --- read a buffer from a remote tape 412 */ 413 static ssize_t 414 _rmt_read(int fildes, void *buf, size_t nbyte) 415 { 416 size_t rc; 417 int rv; 418 ssize_t nread; 419 char *p; 420 char buffer[BUFMAGIC]; 421 422 _DIAGASSERT(buf != NULL); 423 424 (void)snprintf(buffer, sizeof buffer, "R%lu\n", (u_long)nbyte); 425 if (command(fildes, buffer) == -1 || (rv = status(fildes)) == -1) 426 return (-1); 427 428 if (rv > nbyte) 429 rv = nbyte; 430 431 for (rc = rv, p = buf; rc > 0; rc -= nread, p += nread) { 432 if ((nread = read(READ(fildes), p, rc)) <= 0) { 433 rmtabort(fildes); 434 errno = EIO; 435 return (-1); 436 } 437 } 438 439 return rv; 440 } 441 442 443 /* 444 * _rmt_write --- write a buffer to the remote tape 445 */ 446 static ssize_t 447 _rmt_write(int fildes, const void *buf, size_t nbyte) 448 { 449 char buffer[BUFMAGIC]; 450 void (*pstat)(int); 451 452 _DIAGASSERT(buf != NULL); 453 454 (void)snprintf(buffer, sizeof buffer, "W%lu\n", (u_long)nbyte); 455 if (command(fildes, buffer) == -1) 456 return (-1); 457 458 pstat = signal(SIGPIPE, SIG_IGN); 459 if (write(WRITE(fildes), buf, nbyte) == nbyte) { 460 signal(SIGPIPE, pstat); 461 return (status(fildes)); 462 } 463 464 signal(SIGPIPE, pstat); 465 rmtabort(fildes); 466 errno = EIO; 467 return (-1); 468 } 469 470 471 /* 472 * _rmt_lseek --- perform an imitation lseek operation remotely 473 */ 474 static off_t 475 _rmt_lseek(int fildes, off_t offset, int whence) 476 { 477 char buffer[BUFMAGIC]; 478 479 /*LONGLONG*/ 480 (void)snprintf(buffer, sizeof buffer, "L%lld\n%d\n", (long long)offset, 481 whence); 482 if (command(fildes, buffer) == -1) 483 return (-1); 484 485 return (status(fildes)); 486 } 487 488 489 /* 490 * _rmt_ioctl --- perform raw tape operations remotely 491 */ 492 #ifdef RMTIOCTL 493 static int 494 _rmt_ioctl(int fildes, unsigned long op, void *arg) 495 { 496 char c; 497 int rv; 498 size_t rc; 499 ssize_t cnt; 500 char buffer[BUFMAGIC], *p; 501 502 _DIAGASSERT(arg != NULL); 503 504 /* 505 * MTIOCOP is the easy one. nothing is transfered in binary 506 */ 507 508 if (op == MTIOCTOP) { 509 (void)snprintf(buffer, sizeof buffer, "I%d\n%d\n", 510 ((struct mtop *)arg)->mt_op, 511 ((struct mtop *)arg)->mt_count); 512 if (command(fildes, buffer) == -1) 513 return (-1); 514 return (status(fildes)); 515 } 516 517 /* 518 * we can only handle 2 ops, if not the other one, punt 519 */ 520 521 if (op != MTIOCGET) { 522 errno = EINVAL; 523 return (-1); 524 } 525 526 /* 527 * grab the status and read it directly into the structure 528 * this assumes that the status buffer is (hopefully) not 529 * padded and that 2 shorts fit in a long without any word 530 * alignment problems, ie - the whole struct is contiguous 531 * NOTE - this is probably NOT a good assumption. 532 */ 533 534 if (command(fildes, "S") == -1 || (rv = status(fildes)) == -1) 535 return (-1); 536 537 for (rc = rv, p = arg; rc > 0; rc -= cnt, p += cnt) { 538 if ((cnt = read(READ(fildes), p, rc)) <= 0) { 539 rmtabort(fildes); 540 errno = EIO; 541 return (-1); 542 } 543 } 544 545 /* 546 * now we check for byte position. mt_type is a small integer field 547 * (normally) so we will check its magnitude. if it is larger than 548 * 256, we will assume that the bytes are swapped and go through 549 * and reverse all the bytes 550 */ 551 552 if (((struct mtget *)(void *)p)->mt_type < 256) 553 return (0); 554 555 for (cnt = 0; cnt < rc; cnt += 2) { 556 c = p[cnt]; 557 p[cnt] = p[cnt+1]; 558 p[cnt+1] = c; 559 } 560 561 return (0); 562 } 563 #endif /* RMTIOCTL */ 564 565 566 /* 567 * Added routines to replace open(), close(), lseek(), ioctl(), etc. 568 * The preprocessor can be used to remap these the rmtopen(), etc 569 * thus minimizing source changes: 570 * 571 * #ifdef <something> 572 * # define access rmtaccess 573 * # define close rmtclose 574 * # define creat rmtcreat 575 * # define dup rmtdup 576 * # define fcntl rmtfcntl 577 * # define fstat rmtfstat 578 * # define ioctl rmtioctl 579 * # define isatty rmtisatty 580 * # define lseek rmtlseek 581 * # define lstat rmtlstat 582 * # define open rmtopen 583 * # define read rmtread 584 * # define stat rmtstat 585 * # define write rmtwrite 586 * #endif 587 * 588 * -- Fred Fish 589 * 590 * ADR --- I set up a <rmt.h> include file for this 591 * 592 */ 593 594 /* 595 * Note that local vs remote file descriptors are distinquished 596 * by adding a bias to the remote descriptors. This is a quick 597 * and dirty trick that may not be portable to some systems. 598 */ 599 600 #define REM_BIAS 128 601 602 603 /* 604 * Test pathname to see if it is local or remote. A remote device 605 * is any string that contains ":/dev/". Returns 1 if remote, 606 * 0 otherwise. 607 */ 608 609 static int 610 remdev(const char *path) 611 { 612 613 _DIAGASSERT(path != NULL); 614 615 if ((path = strchr(path, ':')) != NULL) { 616 if (strncmp(path + 1, "/dev/", 5) == 0) { 617 return (1); 618 } 619 } 620 return (0); 621 } 622 623 624 /* 625 * Open a local or remote file. Looks just like open(2) to 626 * caller. 627 */ 628 int 629 rmtopen(const char *path, int oflag, ...) 630 { 631 mode_t mode; 632 int fd; 633 va_list ap; 634 va_start(ap, oflag); 635 636 mode = va_arg(ap, mode_t); 637 va_end(ap); 638 639 _DIAGASSERT(path != NULL); 640 641 if (remdev(path)) { 642 fd = _rmt_open(path, oflag, (int)mode); 643 644 return ((fd == -1) ? -1 : (fd + REM_BIAS)); 645 } else { 646 return (open(path, oflag, mode)); 647 } 648 } 649 650 /* 651 * Test pathname for specified access. Looks just like access(2) 652 * to caller. 653 */ 654 655 int 656 rmtaccess(const char *path, int amode) 657 { 658 659 _DIAGASSERT(path != NULL); 660 661 if (remdev(path)) { 662 return (0); /* Let /etc/rmt find out */ 663 } else { 664 return (access(path, amode)); 665 } 666 } 667 668 669 /* 670 * Isrmt. Let a programmer know he has a remote device. 671 */ 672 int 673 isrmt(int fd) 674 { 675 676 return (fd >= REM_BIAS); 677 } 678 679 680 /* 681 * Read from stream. Looks just like read(2) to caller. 682 */ 683 ssize_t 684 rmtread(int fildes, void *buf, size_t nbyte) 685 { 686 687 _DIAGASSERT(buf != NULL); 688 689 if (isrmt(fildes)) { 690 return (_rmt_read(fildes - REM_BIAS, buf, nbyte)); 691 } else { 692 return (read(fildes, buf, nbyte)); 693 } 694 } 695 696 697 /* 698 * Write to stream. Looks just like write(2) to caller. 699 */ 700 ssize_t 701 rmtwrite(int fildes, const void *buf, size_t nbyte) 702 { 703 704 _DIAGASSERT(buf != NULL); 705 706 if (isrmt(fildes)) { 707 return (_rmt_write(fildes - REM_BIAS, buf, nbyte)); 708 } else { 709 return (write(fildes, buf, nbyte)); 710 } 711 } 712 713 /* 714 * Perform lseek on file. Looks just like lseek(2) to caller. 715 */ 716 off_t 717 rmtlseek(int fildes, off_t offset, int whence) 718 { 719 720 if (isrmt(fildes)) { 721 return (_rmt_lseek(fildes - REM_BIAS, offset, whence)); 722 } else { 723 return (lseek(fildes, offset, whence)); 724 } 725 } 726 727 728 /* 729 * Close a file. Looks just like close(2) to caller. 730 */ 731 int 732 rmtclose(int fildes) 733 { 734 735 if (isrmt(fildes)) { 736 return (_rmt_close(fildes - REM_BIAS)); 737 } else { 738 return (close(fildes)); 739 } 740 } 741 742 743 /* 744 * Do ioctl on file. Looks just like ioctl(2) to caller. 745 */ 746 int 747 rmtioctl(int fildes, unsigned long request, ...) 748 { 749 char *arg; 750 va_list ap; 751 va_start(ap, request); 752 753 arg = va_arg(ap, char *); 754 va_end(ap); 755 756 /* XXX: arg may be NULL ? */ 757 758 if (isrmt(fildes)) { 759 #ifdef RMTIOCTL 760 return (_rmt_ioctl(fildes - REM_BIAS, request, arg)); 761 #else 762 errno = EOPNOTSUPP; 763 return (-1); /* For now (fnf) */ 764 #endif 765 } else { 766 return (ioctl(fildes, request, arg)); 767 } 768 } 769 770 771 /* 772 * Duplicate an open file descriptor. Looks just like dup(2) 773 * to caller. 774 */ 775 int 776 rmtdup(int fildes) 777 { 778 779 if (isrmt(fildes)) { 780 errno = EOPNOTSUPP; 781 return (-1); /* For now (fnf) */ 782 } else { 783 return (dup(fildes)); 784 } 785 } 786 787 788 /* 789 * Get file status. Looks just like fstat(2) to caller. 790 */ 791 int 792 rmtfstat(int fildes, struct stat *buf) 793 { 794 795 _DIAGASSERT(buf != NULL); 796 797 if (isrmt(fildes)) { 798 errno = EOPNOTSUPP; 799 return (-1); /* For now (fnf) */ 800 } else { 801 return (fstat(fildes, buf)); 802 } 803 } 804 805 806 /* 807 * Get file status. Looks just like stat(2) to caller. 808 */ 809 int 810 rmtstat(const char *path, struct stat *buf) 811 { 812 813 _DIAGASSERT(path != NULL); 814 _DIAGASSERT(buf != NULL); 815 816 if (remdev(path)) { 817 errno = EOPNOTSUPP; 818 return (-1); /* For now (fnf) */ 819 } else { 820 return (stat(path, buf)); 821 } 822 } 823 824 825 /* 826 * Create a file from scratch. Looks just like creat(2) to the caller. 827 */ 828 int 829 rmtcreat(const char *path, mode_t mode) 830 { 831 832 _DIAGASSERT(path != NULL); 833 834 if (remdev(path)) { 835 return (rmtopen(path, 1 | O_CREAT, mode)); 836 } else { 837 return (creat(path, mode)); 838 } 839 } 840 841 842 /* 843 * Rmtfcntl. Do a remote fcntl operation. 844 */ 845 int 846 rmtfcntl(int fd, int cmd, ...) 847 { 848 void *arg; 849 va_list ap; 850 va_start(ap, cmd); 851 852 arg = va_arg(ap, void *); 853 va_end(ap); 854 855 /* XXX: arg may be NULL ? */ 856 857 if (isrmt(fd)) { 858 errno = EOPNOTSUPP; 859 return (-1); 860 } else { 861 return (fcntl(fd, cmd, arg)); 862 } 863 } 864 865 866 /* 867 * Rmtisatty. Do the isatty function. 868 */ 869 int 870 rmtisatty(int fd) 871 { 872 873 if (isrmt(fd)) 874 return (0); 875 else 876 return (isatty(fd)); 877 } 878 879 880 /* 881 * Get file status, even if symlink. Looks just like lstat(2) to caller. 882 */ 883 int 884 rmtlstat(const char *path, struct stat *buf) 885 { 886 887 _DIAGASSERT(path != NULL); 888 _DIAGASSERT(buf != NULL); 889 890 if (remdev(path)) { 891 errno = EOPNOTSUPP; 892 return (-1); /* For now (fnf) */ 893 } else { 894 return (lstat(path, buf)); 895 } 896 } 897
Indexes created Wed Sep 24 15:09:51 GMT 2025