usr.sbin/rmt/rmt.c

   1 /*
   2  * Copyright (c) 1983, 1993
   3  *      The Regents of the University of California.  All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  * 3. Neither the name of the University nor the names of its contributors
  14  *    may be used to endorse or promote products derived from this software
  15  *    without specific prior written permission.
  16  *
  17  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  18  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  19  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  20  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  21  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  22  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  23  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  24  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  25  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  26  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  27  * SUCH DAMAGE.
  28  *
  29  * @(#) Copyright (c) 1983, 1993 The Regents of the University of California.  All rights reserved.
  30  * @(#)rmt.c    8.1 (Berkeley) 6/6/93
  31  * $FreeBSD: src/usr.sbin/rmt/rmt.c,v 1.7 2000/02/12 01:14:33 mjacob Exp $
  32  */
  33
  34 /*
  35  * rmt
  36  */
  37 #include <sys/types.h>
  38 #include <sys/socket.h>
  39 #include <sys/mtio.h>
  40 #include <errno.h>
  41 #include <fcntl.h>
  42 #include <sgtty.h>
  43 #include <stdio.h>
  44 #include <stdlib.h>
  45 #include <string.h>
  46 #include <unistd.h>
  47
  48 int     tape = -1;
  49
  50 char    *record;
  51 int     maxrecsize = -1;
  52
  53 #define SSIZE   64
  54 char    device[SSIZE];
  55 char    count[SSIZE], mode[SSIZE], pos[SSIZE], op[SSIZE];
  56
  57 char    resp[BUFSIZ];
  58
  59 FILE    *debug;
  60 #define DEBUG(f)        if (debug) fprintf(debug, f)
  61 #define DEBUG1(f,a)     if (debug) fprintf(debug, f, a)
  62 #define DEBUG2(f,a1,a2) if (debug) fprintf(debug, f, a1, a2)
  63
  64 char    *checkbuf(char *, int);
  65 void     error(int);
  66 void     getstring(char *);
  67
  68 int
  69 main(int argc, char **argv)
  70 {
  71         int rval;
  72         char c;
  73         int n, i, cc;
  74
  75         argc--, argv++;
  76         if (argc > 0) {
  77                 debug = fopen(*argv, "w");
  78                 if (debug == NULL)
  79                         exit(1);
  80                 setbuf(debug, NULL);
  81         }
  82 top:
  83         errno = 0;
  84         rval = 0;
  85         if (read(0, &c, 1) != 1)
  86                 exit(0);
  87         switch (c) {
  88
  89         case 'O':
  90                 if (tape >= 0)
  91                         close(tape);
  92                 getstring(device);
  93                 getstring(mode);
  94                 DEBUG2("rmtd: O %s %s\n", device, mode);
  95                 /*
  96                  * XXX the rmt protocol does not provide a means to
  97                  * specify the permission bits; allow rw for everyone,
  98                  * as modified by the users umask
  99                  */
 100                 tape = open(device, atoi(mode), 0666);
 101                 if (tape < 0)
 102                         goto ioerror;
 103                 goto respond;
 104
 105         case 'C':
 106                 DEBUG("rmtd: C\n");
 107                 getstring(device);              /* discard */
 108                 if (close(tape) < 0)
 109                         goto ioerror;
 110                 tape = -1;
 111                 goto respond;
 112
 113         case 'L':
 114                 getstring(count);
 115                 getstring(pos);
 116                 DEBUG2("rmtd: L %s %s\n", count, pos);
 117                 rval = lseek(tape, (off_t)atol(count), atoi(pos));
 118                 if (rval < 0)
 119                         goto ioerror;
 120                 goto respond;
 121
 122         case 'W':
 123                 getstring(count);
 124                 n = atoi(count);
 125                 DEBUG1("rmtd: W %s\n", count);
 126                 record = checkbuf(record, n);
 127                 for (i = 0; i < n; i += cc) {
 128                         cc = read(0, &record[i], n - i);
 129                         if (cc <= 0) {
 130                                 DEBUG("rmtd: premature eof\n");
 131                                 exit(2);
 132                         }
 133                 }
 134                 rval = write(tape, record, n);
 135                 if (rval < 0)
 136                         goto ioerror;
 137                 goto respond;
 138
 139         case 'R':
 140                 getstring(count);
 141                 DEBUG1("rmtd: R %s\n", count);
 142                 n = atoi(count);
 143                 record = checkbuf(record, n);
 144                 rval = read(tape, record, n);
 145                 if (rval < 0)
 146                         goto ioerror;
 147                 sprintf(resp, "A%d\n", rval);
 148                 write(1, resp, strlen(resp));
 149                 write(1, record, rval);
 150                 goto top;
 151
 152         case 'I':
 153                 getstring(op);
 154                 getstring(count);
 155                 DEBUG2("rmtd: I %s %s\n", op, count);
 156                 { struct mtop mtop;
 157                   mtop.mt_op = atoi(op);
 158                   mtop.mt_count = atoi(count);
 159                   if (ioctl(tape, MTIOCTOP, (char *)&mtop) < 0)
 160                         goto ioerror;
 161                   rval = mtop.mt_count;
 162                 }
 163                 goto respond;
 164
 165         case 'S':               /* status */
 166                 DEBUG("rmtd: S\n");
 167                 { struct mtget mtget;
 168                   if (ioctl(tape, MTIOCGET, (char *)&mtget) < 0)
 169                         goto ioerror;
 170                   rval = sizeof (mtget);
 171                   if (rval > 24)        /* original mtget structure size */
 172                         rval = 24;
 173                   sprintf(resp, "A%d\n", rval);
 174                   write(1, resp, strlen(resp));
 175                   write(1, (char *)&mtget, rval);
 176                   goto top;
 177                 }
 178
 179         case 'V':               /* version */
 180                 getstring(op);
 181                 DEBUG1("rmtd: V %s\n", op);
 182                 rval = 2;
 183                 goto respond;
 184
 185         default:
 186                 DEBUG1("rmtd: garbage command %c\n", c);
 187                 exit(3);
 188         }
 189 respond:
 190         DEBUG1("rmtd: A %d\n", rval);
 191         sprintf(resp, "A%d\n", rval);
 192         write(1, resp, strlen(resp));
 193         goto top;
 194 ioerror:
 195         error(errno);
 196         goto top;
 197 }
 198
 199 void
 200 getstring(char *bp)
 201 {
 202         int i;
 203         char *cp = bp;
 204
 205         for (i = 0; i < SSIZE; i++) {
 206                 if (read(0, cp+i, 1) != 1)
 207                         exit(0);
 208                 if (cp[i] == '\n')
 209                         break;
 210         }
 211         cp[i] = '\0';
 212 }
 213
 214 char *
 215 checkbuf(char *record, int size)
 216 {
 217
 218         if (size <= maxrecsize)
 219                 return (record);
 220         if (record != NULL)
 221                 free(record);
 222         record = malloc(size);
 223         if (record == NULL) {
 224                 DEBUG("rmtd: cannot allocate buffer space\n");
 225                 exit(4);
 226         }
 227         maxrecsize = size;
 228         while (size > 1024 &&
 229                setsockopt(0, SOL_SOCKET, SO_RCVBUF, &size, sizeof (size)) < 0)
 230                 size -= 1024;
 231         return (record);
 232 }
 233
 234 void
 235 error(int num)
 236 {
 237
 238         DEBUG2("rmtd: E %d (%s)\n", num, strerror(num));
 239         snprintf(resp, sizeof(resp), "E%d\n%s\n", num, strerror(num));
 240         write(1, resp, strlen(resp));
 241 }