usr/src/cmd/rmt/rmt.c

   1 /*
   2  * CDDL HEADER START
   3  *
   4  * The contents of this file are subject to the terms of the
   5  * Common Development and Distribution License (the "License").
   6  * You may not use this file except in compliance with the License.
   7  *
   8  * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE
   9  * or http://www.opensolaris.org/os/licensing.
  10  * See the License for the specific language governing permissions
  11  * and limitations under the License.
  12  *
  13  * When distributing Covered Code, include this CDDL HEADER in each
  14  * file and include the License file at usr/src/OPENSOLARIS.LICENSE.
  15  * If applicable, add the following below this CDDL HEADER, with the
  16  * fields enclosed by brackets "[]" replaced with your own identifying
  17  * information: Portions Copyright [yyyy] [name of copyright owner]
  18  *
  19  * CDDL HEADER END
  20  */
  21 /*
  22  * Copyright 2005 Sun Microsystems, Inc.  All rights reserved.
  23  * Use is subject to license terms.
  24  */
  25
  26 #pragma ident   "%Z%%M% %I%     %E% SMI"
  27
  28 /*
  29  *  Multi-process streaming 4.3bsd /etc/rmt server.
  30  *  Has three locks (for stdin, stdout, and the tape)
  31  *  that are passed by signals and received by sigpause().
  32  */
  33
  34 #include <stdio.h>
  35 #include <locale.h>
  36 #include <sys/types.h>
  37 #include <errno.h>
  38 #include <fcntl.h>
  39 #include <string.h>
  40 #include <signal.h>
  41 #include <setjmp.h>
  42 #include <sys/ioctl.h>
  43 #include <sys/mtio.h>
  44 #include <sys/wait.h>
  45 #include <stdlib.h>
  46 #include <unistd.h>
  47 #include <sys/param.h>
  48
  49 static sigset_t cmdmask, maskall, newmask;
  50 static sigset_t sendmask, tapemask;
  51
  52 static struct mtop mtop;
  53 static struct mtget mtget;
  54 static jmp_buf sjbuf;
  55
  56 #define RECV    SIGIO
  57 #define TAPE    SIGURG
  58 #define SEND    SIGALRM
  59 #define ERROR   SIGTERM
  60 #define OPEN    SIGUSR1
  61 #define CLOSE   SIGUSR2
  62
  63 /*
  64  * Support for Version 1 of the extended RMT protocol:
  65  * Placing RMTIVERSION (-1) into the mt_op field of the ioctl ('I')
  66  * request will return the current version of the RMT protocol that
  67  * the server supports.  For servers that don't support Version 1,
  68  * an error is returned and the client knows to only use Version 0
  69  * (stock BSD) calls, which include mt_op values in the range of [0-7].
  70  *
  71  * Note: The RMTIVERSION request must be made in order for the extended
  72  * protocol commands to be recognized.
  73  */
  74 #define RMTIVERSION     -1
  75 #define RMT_VERSION     1
  76
  77 /*
  78  * These requests are made to the extended RMT protocol by specifying the
  79  * new 'i' command of RMT Protocol Version 1.  They are intended to allow
  80  * an intelligent client to communicate with both BSD and Solaris RMT
  81  * servers heterogeneously.  The 'i' command taks an mtop structure as
  82  * argument, exactly like the 'I' command does.
  83  */
  84 #define RMTICACHE       0
  85 #define RMTINOCACHE     1
  86 #define RMTIRETEN       2
  87 #define RMTIERASE       3
  88 #define RMTIEOM         4
  89 #define RMTINBSF        5
  90
  91 /*
  92  * These requests are made to the extended RMT protocol by specifying the
  93  * new 's' command of RMT Protocol Version 1.  They are intended to allow
  94  * an intelligent client to obtain "mt status" information with both BSD
  95  * and Solaris RMT servers heterogeneously.  They return the requested
  96  * piece of the mtget structure as an ascii integer.  The request is made
  97  * by sending the required character immediately after the 's' character
  98  * without any trailing newline.  A single ascii integer is returned, else
  99  * an error is returned.
 100  */
 101 #define MTS_TYPE        'T'             /* mtget.mt_type */
 102 #define MTS_DSREG       'D'             /* mtget.mt_dsreg */
 103 #define MTS_ERREG       'E'             /* mtget.mt_erreg */
 104 #define MTS_RESID       'R'             /* mtget.mt_resid */
 105 #define MTS_FILENO      'F'             /* mtget.mt_fileno */
 106 #define MTS_BLKNO       'B'             /* mtget.mt_blkno */
 107 #define MTS_FLAGS       'f'             /* mtget.mt_flags */
 108 #define MTS_BF          'b'             /* mtget.mt_bf */
 109
 110 #define MAXCHILD 1
 111 static pid_t    childpid[MAXCHILD];
 112 static int      children;
 113
 114 static int      tape = -1;
 115 static size_t   maxrecsize = 0;
 116 static char     *record;
 117
 118 #define SSIZE   64
 119 static char     pos[SSIZE], op[SSIZE], mode[SSIZE], count[SSIZE];
 120 static char     device[MAXPATHLEN];
 121
 122 static FILE     *debug;
 123 #define DEBUG(f)                if (debug) (void) fprintf(debug, (f))
 124 #define DEBUG1(f, a)            if (debug) (void) fprintf(debug, (f), (a))
 125 #define DEBUG2(f, a, b)         if (debug) (void) fprintf(debug, (f), (a), (b))
 126 #define DEBUG3(f, a, b, c)      if (debug) \
 127                                     (void) fprintf(debug, (f), (a), (b), (c))
 128
 129 static char key;
 130
 131 #ifdef __STDC__
 132 static void respond(offset_t, int);
 133 static void getstring(char *, size_t);
 134 static void checkbuf(size_t);
 135 #else
 136 static void respond();
 137 static void getstring();
 138 static void checkbuf();
 139 #endif
 140
 141 static void
 142 catch(int sig)
 143 {
 144         switch (sig) {
 145         default:    return;
 146         case OPEN:  key = 'O';  break;
 147         case CLOSE: key = 'C';  break;
 148         case ERROR: key = 'E';  break;
 149         }
 150         (void) sigprocmask(SIG_SETMASK, &maskall, (sigset_t *)0);
 151         longjmp(sjbuf, 1);
 152 }
 153
 154 int
 155 main(int argc, char *argv[])
 156 {
 157         struct sigaction sa;
 158         pid_t parent = getpid(), next = parent;
 159         int saverr;
 160         offset_t rval;
 161         ssize_t cc;
 162         size_t n, i;
 163
 164         (void) setlocale(LC_ALL, "");
 165 #if !defined(TEXT_DOMAIN)       /* Should be defined by cc -D */
 166 #define TEXT_DOMAIN "SYS_TEST"
 167 #endif
 168         (void) textdomain(TEXT_DOMAIN);
 169
 170         if (argc > 1) {
 171                 if ((debug = fopen(argv[1], "w")) == NULL)
 172                         exit(1);
 173                 setbuf(debug, NULL);
 174         }
 175         (void) sigemptyset(&maskall);
 176         (void) sigaddset(&maskall, RECV);
 177         (void) sigaddset(&maskall, OPEN);
 178         (void) sigaddset(&maskall, CLOSE);
 179         (void) sigaddset(&maskall, ERROR);
 180         (void) sigaddset(&maskall, TAPE);
 181         (void) sigaddset(&maskall, SEND);
 182
 183         tapemask = maskall;
 184         (void) sigdelset(&tapemask, TAPE);
 185
 186         sendmask = maskall;
 187         (void) sigdelset(&sendmask, SEND);
 188
 189         (void) sigemptyset(&cmdmask);
 190         (void) sigaddset(&cmdmask, TAPE);
 191         (void) sigaddset(&cmdmask, SEND);
 192
 193         (void) sigemptyset(&sa.sa_mask);
 194
 195         sa.sa_handler = catch;
 196         sa.sa_flags = SA_RESTART;
 197         (void) sigaction(RECV, &sa, (struct sigaction *)0);
 198         (void) sigaction(SEND, &sa, (struct sigaction *)0);
 199         (void) sigaction(TAPE, &sa, (struct sigaction *)0);
 200         (void) sigaction(OPEN, &sa, (struct sigaction *)0);
 201         (void) sigaction(CLOSE, &sa, (struct sigaction *)0);
 202         (void) sigaction(ERROR, &sa, (struct sigaction *)0);
 203
 204         (void) sigprocmask(SIG_SETMASK, &maskall, (sigset_t *)0);
 205
 206         (void) kill(parent, TAPE);
 207         (void) kill(parent, SEND);
 208
 209         while (read(0, &key, 1) == 1) {
 210                 switch (key) {
 211                 case 'L':               /* lseek */
 212                         getstring(count, sizeof (count));
 213                         getstring(pos, sizeof (pos));
 214                         DEBUG2("rmtd: L %s %s\n", count, pos);
 215                         (void) kill(next, RECV);
 216                         (void) sigsuspend(&tapemask);
 217                         rval = llseek(tape, atoll(count), atoi(pos));
 218                         saverr = errno;
 219                         (void) kill(next, TAPE);
 220                         (void) sigsuspend(&sendmask);
 221                         respond(rval, saverr);
 222                         break;
 223
 224                 case 'I':               /* ioctl */
 225                 case 'i': {             /* extended version ioctl */
 226                         int bad = 0;
 227
 228                         getstring(op, sizeof (op));
 229                         getstring(count, sizeof (count));
 230                         DEBUG3("rmtd: %c %s %s\n", key, op, count);
 231                         mtop.mt_op = atoi(op);
 232                         mtop.mt_count = atoi(count);
 233                         if (key == 'i') {
 234                                 /*
 235                                  * Map the supported compatibility defines
 236                                  * into real ioctl values.
 237                                  */
 238                                 switch (mtop.mt_op) {
 239                                 case RMTICACHE:
 240                                 case RMTINOCACHE:       /* not support on Sun */
 241                                         bad = 1;
 242                                         break;
 243                                 case RMTIRETEN:
 244                                         mtop.mt_op = MTRETEN;
 245                                         break;
 246                                 case RMTIERASE:
 247                                         mtop.mt_op = MTERASE;
 248                                         break;
 249                                 case RMTIEOM:
 250                                         mtop.mt_op = MTEOM;
 251                                         break;
 252                                 case RMTINBSF:
 253                                         mtop.mt_op = MTNBSF;
 254                                         break;
 255                                 default:
 256                                         bad = 1;
 257                                         break;
 258                                 }
 259                         }
 260                         if (bad) {
 261                                 respond(-1LL, EINVAL);
 262                         } else {
 263                                 (void) kill(next, RECV);
 264                                 (void) sigsuspend(&tapemask);
 265                                 if (mtop.mt_op == RMTIVERSION) {
 266                                         mtop.mt_count = RMT_VERSION;
 267                                         rval = (offset_t)mtop.mt_count;
 268                                 } else {
 269                                         rval = (offset_t)ioctl(tape, MTIOCTOP,
 270                                             (char *)&mtop);
 271                                 }
 272                                 saverr = errno;
 273                                 (void) kill(next, TAPE);
 274                                 (void) sigsuspend(&sendmask);
 275                                 respond(rval < 0 ?
 276                                     rval : (offset_t)mtop.mt_count,
 277                                     saverr);
 278                         }
 279                         break;
 280                 }
 281
 282                 case 'S':               /* status */
 283                 case 's': {             /* extended status */
 284                         char skey;
 285
 286                         DEBUG1("rmtd: %c\n", key);
 287                         if (key == 's') {
 288                                 if (read(0, &skey, 1) != 1)
 289                                         continue;
 290                         }
 291                         (void) kill(next, RECV);
 292                         (void) sigsuspend(&tapemask);
 293                         errno = 0;
 294                         rval = (offset_t)ioctl(tape, MTIOCGET, (char *)&mtget);
 295                         saverr = errno;
 296                         (void) kill(next, TAPE);
 297                         (void) sigsuspend(&sendmask);
 298                         if (rval < 0)
 299                                 respond(rval, saverr);
 300                         else {
 301                                 if (key == 's') {       /* extended status */
 302                                         DEBUG1("rmtd: s%c\n", key);
 303                                         switch (skey) {
 304                                         case MTS_TYPE:
 305                                                 respond(
 306                                                     (offset_t)mtget.mt_type,
 307                                                     saverr);
 308                                                 break;
 309                                         case MTS_DSREG:
 310                                                 respond(
 311                                                     (offset_t)mtget.mt_dsreg,
 312                                                     saverr);
 313                                                 break;
 314                                         case MTS_ERREG:
 315                                                 respond(
 316                                                     (offset_t)mtget.mt_erreg,
 317                                                     saverr);
 318                                                 break;
 319                                         case MTS_RESID:
 320                                                 respond(
 321                                                     (offset_t)mtget.mt_resid,
 322                                                     saverr);
 323                                                 break;
 324                                         case MTS_FILENO:
 325                                                 respond(
 326                                                     (offset_t)mtget.mt_fileno,
 327                                                     saverr);
 328                                                 break;
 329                                         case MTS_BLKNO:
 330                                                 respond(
 331                                                     (offset_t)mtget.mt_blkno,
 332                                                     saverr);
 333                                                 break;
 334                                         case MTS_FLAGS:
 335                                                 respond(
 336                                                     (offset_t)mtget.mt_flags,
 337                                                     saverr);
 338                                                 break;
 339                                         case MTS_BF:
 340                                                 respond((offset_t)mtget.mt_bf,
 341                                                     saverr);
 342                                                 break;
 343                                         default:
 344                                                 respond(-1LL, EINVAL);
 345                                                 break;
 346                                         }
 347                                 } else {
 348                                         respond((offset_t)sizeof (mtget),
 349                                             saverr);
 350                                         (void) write(1, (char *)&mtget,
 351                                             sizeof (mtget));
 352                                 }
 353                         }
 354                         break;
 355                 }
 356
 357                 case 'W':
 358                         getstring(count, sizeof (count));
 359                         n = (size_t)atol(count);
 360                         checkbuf(n);
 361                         DEBUG1("rmtd: W %s\n", count);
 362 #ifdef lint
 363                         cc = 0;
 364 #endif
 365                         for (i = 0; i < n; i += (size_t)cc) {
 366                                 cc = read(0, &record[i], n - i);
 367                                 if (cc <= 0) {
 368                                         DEBUG1(gettext("%s: premature eof\n"),
 369                                                 "rmtd");
 370                                         exit(2);
 371                                 }
 372                         }
 373                         (void) kill(next, RECV);
 374                         (void) sigsuspend(&tapemask);
 375                         rval = (offset_t)write(tape, record, n);
 376                         saverr = errno;
 377                         (void) kill(next, TAPE);
 378                         (void) sigsuspend(&sendmask);
 379                         respond(rval, saverr);
 380                         break;
 381
 382                 case 'R':
 383                         getstring(count, sizeof (count));
 384                         n = (size_t)atol(count);
 385                         checkbuf(n);
 386                         DEBUG1("rmtd: R %s\n", count);
 387                         (void) kill(next, RECV);
 388                         (void) sigsuspend(&tapemask);
 389                         rval = (offset_t)read(tape, record, n);
 390                         saverr = errno;
 391                         (void) kill(next, TAPE);
 392                         (void) sigsuspend(&sendmask);
 393                         respond(rval, saverr);
 394                         (void) write(1, record, (size_t)rval);
 395                         break;
 396
 397                 default:
 398                         DEBUG2(gettext("%s: garbage command '%c'\n"),
 399                                 "rmtd", key);
 400                         /*FALLTHROUGH*/
 401
 402                 case 'C':
 403                 case 'O':
 404                         /* rendezvous back into a single process */
 405                         if (setjmp(sjbuf) == 0 || getpid() != parent) {
 406                                 (void) sigsuspend(&tapemask);
 407                                 (void) sigsuspend(&sendmask);
 408                                 (void) kill(parent, key == 'O' ? OPEN :
 409                                         key == 'C' ? CLOSE : ERROR);
 410                                 (void) sigemptyset(&newmask);
 411                                 (void) sigsuspend(&newmask);
 412                         }
 413                         while (children > 0) {
 414                                 (void) kill(childpid[--children], SIGKILL);
 415                                 while (wait(NULL) != childpid[children])
 416                                         ;
 417                         }
 418                         next = parent;
 419                         if (key == 'C') {
 420                                 getstring(device, sizeof (device));
 421                                 DEBUG1("rmtd: C %s\n", device);
 422                                 rval = (offset_t)close(tape);
 423                                 respond(rval, errno);
 424                                 (void) kill(parent, TAPE);
 425                                 (void) kill(parent, SEND);
 426                                 continue;
 427                         }
 428                         if (key != 'O')                 /* garbage command */
 429                                 exit(3);
 430                         (void) close(tape);
 431                         getstring(device, sizeof (device));
 432                         getstring(mode, sizeof (mode));
 433                         DEBUG2("rmtd: O %s %s\n", device, mode);
 434                         /*
 435                          * Due to incompatibilities in the
 436                          * assignment of mode bits between
 437                          * BSD and System V, we strip all
 438                          * but the read/write bits.  However,
 439                          * we also want to handle things larger
 440                          * than 2GB, so we also force O_LARGEFILE.
 441                          */
 442                         tape = open(device, O_LARGEFILE |
 443                             (atoi(mode) & (O_RDONLY|O_WRONLY|O_RDWR)));
 444                         respond((offset_t)tape, errno);
 445                         if (tape >= 0)                  /* fork off */
 446                                 while (children < MAXCHILD &&
 447                                         (childpid[children] = fork()) > 0)
 448                                                 next = childpid[children++];
 449                         if (next == parent) {
 450                                 (void) kill(parent, RECV);
 451                                 (void) kill(parent, TAPE);
 452                                 (void) kill(parent, SEND);
 453                         }
 454                         (void) sigsuspend(&cmdmask);
 455                         continue;
 456                 }
 457                 (void) kill(next, SEND);
 458                 (void) sigsuspend(&cmdmask);
 459         }
 460         (void) kill(next, RECV);
 461         return (0);
 462 }
 463
 464 static void
 465 respond(offset_t rval, int Errno)
 466 {
 467         char resp[SSIZE];
 468         char *errstr = strerror(Errno);
 469
 470         if (rval < 0) {
 471                 (void) snprintf(resp, SSIZE, "E%d\n%s\n", Errno, errstr);
 472                 DEBUG2("rmtd: E %d (%s)\n", Errno, errstr);
 473         } else {
 474                 (void) snprintf(resp, SSIZE, "A%lld\n", rval);
 475                 DEBUG1("rmtd: A %lld\n", rval);
 476         }
 477         resp[SSIZE - 1] = '\0';
 478         (void) write(1, resp, (int)strlen(resp));
 479 }
 480
 481 static void
 482 getstring(char *cp, size_t size)
 483 {
 484         char *limit = cp + size - 1;
 485
 486         cp--;                   /* nullify first increment */
 487         do {
 488                 cp++;
 489                 if (read(0, cp, 1) != 1)
 490                         exit(0);
 491         } while ((*cp != '\n') && (cp < limit));
 492         *cp = '\0';
 493 }
 494
 495 static void
 496 checkbuf(size_t size)
 497 {
 498         if (size <= maxrecsize)
 499                 return;
 500         if (record != 0)
 501                 free(record);
 502         if ((record = malloc(size)) == NULL) {
 503                 DEBUG2(gettext("%s: cannot allocate %ld-byte buffer\n"),
 504                     size, "rmtd");
 505                 exit(4);
 506         }
 507         maxrecsize = size;
 508 }