Dogcows Code - chaz/tar/blob - src/rmt.c

   1 /* Remote connection server.
   2    Copyright (C) 1994, 1995, 1996 Free Software Foundation, Inc.
   3
   4    This program is free software; you can redistribute it and/or modify it
   5    under the terms of the GNU General Public License as published by the
   6    Free Software Foundation; either version 2, or (at your option) any later
   7    version.
   8
   9    This program is distributed in the hope that it will be useful, but
  10    WITHOUT ANY WARRANTY; without even the implied warranty of
  11    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General
  12    Public License for more details.
  13
  14    You should have received a copy of the GNU General Public License along
  15    with this program; if not, write to the Free Software Foundation, Inc.,
  16    59 Place - Suite 330, Boston, MA 02111-1307, USA.  */
  17
  18 /* Copyright (C) 1983 Regents of the University of California.
  19    All rights reserved.
  20
  21    Redistribution and use in source and binary forms are permitted provided
  22    that the above copyright notice and this paragraph are duplicated in all
  23    such forms and that any documentation, advertising materials, and other
  24    materials related to such distribution and use acknowledge that the
  25    software was developed by the University of California, Berkeley.  The
  26    name of the University may not be used to endorse or promote products
  27    derived from this software without specific prior written permission.
  28    THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR IMPLIED
  29    WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED WARRANTIES OF
  30    MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.  */
  31
  32 #include "system.h"
  33
  34 #include <sys/socket.h>
  35
  36 #ifndef EXIT_FAILURE
  37 # define EXIT_FAILURE 1
  38 #endif
  39 #ifndef EXIT_SUCCESS
  40 # define EXIT_SUCCESS 0
  41 #endif
  42
  43 /* Maximum size of a string from the requesting program.  */
  44 #define STRING_SIZE 64
  45
  46 /* Name of executing program.  */
  47 const char *program_name;
  48
  49 /* File descriptor of the tape device, or negative if none open.  */
  50 static int tape = -1;
  51
  52 /* Buffer containing transferred data, and its allocated size.  */
  53 static char *record_buffer = NULL;
  54 static int allocated_size = -1;
  55
  56 /* Buffer for constructing the reply.  */
  57 static char reply_buffer[BUFSIZ];
  58
  59 /* Debugging tools.  */
  60
  61 static FILE *debug_file = NULL;
  62
  63 #define DEBUG(File) \
  64   if (debug_file) fprintf(debug_file, File)
  65
  66 #define DEBUG1(File, Arg) \
  67   if (debug_file) fprintf(debug_file, File, Arg)
  68
  69 #define DEBUG2(File, Arg1, Arg2) \
  70   if (debug_file) fprintf(debug_file, File, Arg1, Arg2)
  71
  72 /*------------------------------------------------.
  73 | Return an error string, given an error number.  |
  74 `------------------------------------------------*/
  75
  76 #if HAVE_STRERROR
  77 # ifndef strerror
  78 char *strerror ();
  79 # endif
  80 #else
  81 static char *
  82 private_strerror (int errnum)
  83 {
  84   extern const char *const sys_errlist[];
  85   extern int sys_nerr;
  86
  87   if (errnum > 0 && errnum <= sys_nerr)
  88     return sys_errlist[errnum];
  89   return N_("Unknown system error");
  90 }
  91 # define strerror private_strerror
  92 #endif
  93
  94 /*---.
  95 | ?  |
  96 `---*/
  97
  98 static void
  99 report_error_message (const char *string)
 100 {
 101   DEBUG1 ("rmtd: E 0 (%s)\n", string);
 102
 103   sprintf (reply_buffer, "E0\n%s\n", string);
 104   write (1, reply_buffer, strlen (reply_buffer));
 105 }
 106
 107 /*---.
 108 | ?  |
 109 `---*/
 110
 111 static void
 112 report_numbered_error (int num)
 113 {
 114   DEBUG2 ("rmtd: E %d (%s)\n", num, strerror (num));
 115
 116   sprintf (reply_buffer, "E%d\n%s\n", num, strerror (num));
 117   write (1, reply_buffer, strlen (reply_buffer));
 118 }
 119
 120 /*---.
 121 | ?  |
 122 `---*/
 123
 124 static void
 125 get_string (char *string)
 126 {
 127   int counter;
 128
 129   for (counter = 0; counter < STRING_SIZE; counter++)
 130     {
 131       if (read (0, string + counter, 1) != 1)
 132         exit (EXIT_SUCCESS);
 133
 134       if (string[counter] == '\n')
 135         break;
 136     }
 137   string[counter] = '\0';
 138 }
 139
 140 /*---.
 141 | ?  |
 142 `---*/
 143
 144 static void
 145 prepare_record_buffer (int size)
 146 {
 147   if (size <= allocated_size)
 148     return;
 149
 150   if (record_buffer)
 151     free (record_buffer);
 152
 153   record_buffer = malloc ((size_t) size);
 154
 155   if (record_buffer == NULL)
 156     {
 157       DEBUG (_("rmtd: Cannot allocate buffer space\n"));
 158
 159       report_error_message (N_("Cannot allocate buffer space"));
 160       exit (EXIT_FAILURE);      /* exit status used to be 4 */
 161     }
 162
 163   allocated_size = size;
 164
 165 #ifdef SO_RCVBUF
 166   while (size > 1024 &&
 167    setsockopt (0, SOL_SOCKET, SO_RCVBUF, (char *) &size, sizeof (size)) < 0)
 168     size -= 1024;
 169 #else
 170   /* FIXME: I do not see any purpose to the following line...  Sigh! */
 171   size = 1 + ((size - 1) % 1024);
 172 #endif
 173 }
 174
 175 /*---.
 176 | ?  |
 177 `---*/
 178
 179 int
 180 main (int argc, char *const *argv)
 181 {
 182   char command;
 183   int status;
 184
 185   /* FIXME: Localisation is meaningless, unless --help and --version are
 186      locally used.  Localisation would be best accomplished by the calling
 187      tar, on messages found within error packets.  */
 188
 189   program_name = argv[0];
 190   setlocale (LC_ALL, "");
 191   bindtextdomain (PACKAGE, LOCALEDIR);
 192   textdomain (PACKAGE);
 193
 194   /* FIXME: Implement --help and --version as for any other GNU program.  */
 195
 196   argc--, argv++;
 197   if (argc > 0)
 198     {
 199       debug_file = fopen (*argv, "w");
 200       if (debug_file == 0)
 201         {
 202           report_numbered_error (errno);
 203           exit (EXIT_FAILURE);
 204         }
 205       setbuf (debug_file, NULL);
 206     }
 207
 208 top:
 209   errno = 0;                    /* FIXME: errno should be read-only */
 210   status = 0;
 211   if (read (0, &command, 1) != 1)
 212     exit (EXIT_SUCCESS);
 213
 214   switch (command)
 215     {
 216       /* FIXME: Maybe 'H' and 'V' for --help and --version output?  */
 217
 218     case 'O':
 219       {
 220         char device_string[STRING_SIZE];
 221         char mode_string[STRING_SIZE];
 222
 223         get_string (device_string);
 224         get_string (mode_string);
 225         DEBUG2 ("rmtd: O %s %s\n", device_string, mode_string);
 226
 227         if (tape >= 0)
 228           close (tape);
 229
 230 #if defined (i386) && defined (AIX)
 231
 232         /* This is alleged to fix a byte ordering problem.  I'm quite
 233            suspicious if it's right. -- mib.  */
 234
 235         {
 236           int old_mode = atoi (mode_string);
 237           int new_mode = 0;
 238
 239           if ((old_mode & 3) == 0)
 240             new_mode |= O_RDONLY;
 241           if (old_mode & 1)
 242             new_mode |= O_WRONLY;
 243           if (old_mode & 2)
 244             new_mode |= O_RDWR;
 245           if (old_mode & 0x0008)
 246             new_mode |= O_APPEND;
 247           if (old_mode & 0x0200)
 248             new_mode |= O_CREAT;
 249           if (old_mode & 0x0400)
 250             new_mode |= O_TRUNC;
 251           if (old_mode & 0x0800)
 252             new_mode |= O_EXCL;
 253           tape = open (device_string, new_mode, 0666);
 254         }
 255 #else
 256         tape = open (device_string, atoi (mode_string), 0666);
 257 #endif
 258         if (tape < 0)
 259           goto ioerror;
 260         goto respond;
 261       }
 262
 263     case 'C':
 264       {
 265         char device_string[STRING_SIZE];
 266
 267         get_string (device_string); /* discard */
 268         DEBUG ("rmtd: C\n");
 269
 270         if (close (tape) < 0)
 271           goto ioerror;
 272         tape = -1;
 273         goto respond;
 274       }
 275
 276     case 'L':
 277       {
 278         char count_string[STRING_SIZE];
 279         char position_string[STRING_SIZE];
 280
 281         get_string (count_string);
 282         get_string (position_string);
 283         DEBUG2 ("rmtd: L %s %s\n", count_string, position_string);
 284
 285         status
 286           = lseek (tape, (off_t) atol (count_string), atoi (position_string));
 287         if (status < 0)
 288           goto ioerror;
 289         goto respond;
 290       }
 291
 292     case 'W':
 293       {
 294         char count_string[STRING_SIZE];
 295         int size;
 296         int counter;
 297
 298         get_string (count_string);
 299         size = atoi (count_string);
 300         DEBUG1 ("rmtd: W %s\n", count_string);
 301
 302         prepare_record_buffer (size);
 303         for (counter = 0; counter < size; counter += status)
 304           {
 305             status = read (0, &record_buffer[counter], size - counter);
 306             if (status <= 0)
 307               {
 308                 DEBUG (_("rmtd: Premature eof\n"));
 309
 310                 report_error_message (N_("Premature end of file"));
 311                 exit (EXIT_FAILURE); /* exit status used to be 2 */
 312               }
 313           }
 314         status = write (tape, record_buffer, size);
 315         if (status < 0)
 316           goto ioerror;
 317         goto respond;
 318       }
 319
 320     case 'R':
 321       {
 322         char count_string[STRING_SIZE];
 323         int size;
 324
 325         get_string (count_string);
 326         DEBUG1 ("rmtd: R %s\n", count_string);
 327
 328         size = atoi (count_string);
 329         prepare_record_buffer (size);
 330         status = read (tape, record_buffer, size);
 331         if (status < 0)
 332           goto ioerror;
 333         sprintf (reply_buffer, "A%d\n", status);
 334         write (1, reply_buffer, strlen (reply_buffer));
 335         write (1, record_buffer, status);
 336         goto top;
 337       }
 338
 339     case 'I':
 340       {
 341         char operation_string[STRING_SIZE];
 342         char count_string[STRING_SIZE];
 343
 344         get_string (operation_string);
 345         get_string  (count_string);
 346         DEBUG2 ("rmtd: I %s %s\n", operation_string, count_string);
 347
 348 #ifdef MTIOCTOP
 349         {
 350           struct mtop mtop;
 351
 352           mtop.mt_op = atoi (operation_string);
 353           mtop.mt_count = atoi (count_string);
 354           if (ioctl (tape, MTIOCTOP, (char *) &mtop) < 0)
 355             goto ioerror;
 356           status = mtop.mt_count;
 357         }
 358 #endif
 359         goto respond;
 360       }
 361
 362     case 'S':                   /* status */
 363       {
 364         DEBUG ("rmtd: S\n");
 365
 366 #ifdef MTIOCGET
 367         {
 368           struct mtget operation;
 369
 370           if (ioctl (tape, MTIOCGET, (char *) &operation) < 0)
 371             goto ioerror;
 372           status = sizeof (operation);
 373           sprintf (reply_buffer, "A%d\n", status);
 374           write (1, reply_buffer, strlen (reply_buffer));
 375           write (1, (char *) &operation, sizeof (operation));
 376         }
 377 #endif
 378         goto top;
 379       }
 380
 381     default:
 382       DEBUG1 (_("rmtd: Garbage command %c\n"), command);
 383
 384       report_error_message (N_("Garbage command"));
 385       exit (EXIT_FAILURE);      /* exit status used to be 3 */
 386     }
 387
 388 respond:
 389   DEBUG1 ("rmtd: A %d\n", status);
 390
 391   sprintf (reply_buffer, "A%d\n", status);
 392   write (1, reply_buffer, strlen (reply_buffer));
 393   goto top;
 394
 395 ioerror:
 396   report_numbered_error (errno);
 397   goto top;
 398 }