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

   1 /* Remote connection server.
   2    Copyright 1994, 1995, 1996, 1997, 1999 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 size_t allocated_size = 0;
  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 char *sys_errlist[];
  85   extern int sys_nerr;
  86
  87   if (errnum > 0 && errnum <= sys_nerr)
  88     return _(sys_errlist[errnum]);
  89   return _("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   full_write (STDOUT_FILENO, 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   full_write (STDOUT_FILENO, 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 (full_read (STDIN_FILENO, 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 (size_t size)
 146 {
 147   if (size <= allocated_size)
 148     return;
 149
 150   if (record_buffer)
 151     free (record_buffer);
 152
 153   record_buffer = malloc (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 (STDIN_FILENO, SOL_SOCKET, SO_RCVBUF,
 168                       (char *) &size, sizeof size)
 169           < 0))
 170     size -= 1024;
 171 #else
 172   /* FIXME: I do not see any purpose to the following line...  Sigh! */
 173   size = 1 + ((size - 1) % 1024);
 174 #endif
 175 }
 176
 177 /*---.
 178 | ?  |
 179 `---*/
 180
 181 int
 182 main (int argc, char *const *argv)
 183 {
 184   char command;
 185   long status;
 186
 187   /* FIXME: Localisation is meaningless, unless --help and --version are
 188      locally used.  Localisation would be best accomplished by the calling
 189      tar, on messages found within error packets.  */
 190
 191   program_name = argv[0];
 192   setlocale (LC_ALL, "");
 193   bindtextdomain (PACKAGE, LOCALEDIR);
 194   textdomain (PACKAGE);
 195
 196   /* FIXME: Implement --help and --version as for any other GNU program.  */
 197
 198   argc--, argv++;
 199   if (argc > 0)
 200     {
 201       debug_file = fopen (*argv, "w");
 202       if (debug_file == 0)
 203         {
 204           report_numbered_error (errno);
 205           exit (EXIT_FAILURE);
 206         }
 207       setbuf (debug_file, NULL);
 208     }
 209
 210 top:
 211   errno = 0;                    /* FIXME: errno should be read-only */
 212   status = 0;
 213   if (full_read (STDIN_FILENO, &command, 1) != 1)
 214     exit (EXIT_SUCCESS);
 215
 216   switch (command)
 217     {
 218       /* FIXME: Maybe 'H' and 'V' for --help and --version output?  */
 219
 220     case 'O':
 221       {
 222         char device_string[STRING_SIZE];
 223         char mode_string[STRING_SIZE];
 224
 225         get_string (device_string);
 226         get_string (mode_string);
 227         DEBUG2 ("rmtd: O %s %s\n", device_string, mode_string);
 228
 229         if (tape >= 0)
 230           close (tape);
 231
 232         tape = open (device_string, atoi (mode_string), 0666);
 233         if (tape < 0)
 234           goto ioerror;
 235         goto respond;
 236       }
 237
 238     case 'C':
 239       {
 240         char device_string[STRING_SIZE];
 241
 242         get_string (device_string); /* discard */
 243         DEBUG ("rmtd: C\n");
 244
 245         if (close (tape) < 0)
 246           goto ioerror;
 247         tape = -1;
 248         goto respond;
 249       }
 250
 251     case 'L':
 252       {
 253         char count_string[STRING_SIZE];
 254         char position_string[STRING_SIZE];
 255         off_t count = 0;
 256         int negative;
 257         char *p;
 258
 259         get_string (count_string);
 260         get_string (position_string);
 261         DEBUG2 ("rmtd: L %s %s\n", count_string, position_string);
 262
 263         /* Parse count_string, taking care to check for overflow.
 264            We can't use standard functions,
 265            since off_t might be longer than long.  */
 266
 267         for (p = count_string;  *p == ' ' || *p == '\t';  p++)
 268           continue;
 269
 270         negative = *p == '-';
 271         p += negative || *p == '+';
 272
 273         for (;;)
 274           {
 275             int digit = *p++ - '0';
 276             if (9 < (unsigned) digit)
 277               break;
 278             else
 279               {
 280                 off_t c10 = 10 * count;
 281                 off_t nc = negative ? c10 - digit : c10 + digit;
 282                 if (c10 / 10 != count || (negative ? c10 < nc : nc < c10))
 283                   {
 284                     report_error_message (N_("Seek offset out of range"));
 285                     exit (EXIT_FAILURE);
 286                   }
 287                 count = nc;
 288               }
 289           }
 290
 291         count = lseek (tape, count, atoi (position_string));
 292         if (count < 0)
 293           goto ioerror;
 294
 295         /* Convert count back to string for reply.
 296            We can't use sprintf, since off_t might be longer than long.  */
 297         p = count_string + sizeof count_string;
 298         *--p = '\0';
 299         do
 300           *--p = '0' + (int) (count % 10);
 301         while ((count /= 10) != 0);
 302
 303         DEBUG1 ("rmtd: A %s\n", p);
 304
 305         sprintf (reply_buffer, "A%s\n", p);
 306         full_write (STDOUT_FILENO, reply_buffer, strlen (reply_buffer));
 307         goto top;
 308       }
 309
 310     case 'W':
 311       {
 312         char count_string[STRING_SIZE];
 313         size_t size;
 314         size_t counter;
 315
 316         get_string (count_string);
 317         size = atol (count_string);
 318         DEBUG1 ("rmtd: W %s\n", count_string);
 319
 320         prepare_record_buffer (size);
 321         for (counter = 0; counter < size; counter += status)
 322           {
 323             status = full_read (STDIN_FILENO, &record_buffer[counter],
 324                            size - counter);
 325             if (status <= 0)
 326               {
 327                 DEBUG (_("rmtd: Premature eof\n"));
 328
 329                 report_error_message (N_("Premature end of file"));
 330                 exit (EXIT_FAILURE); /* exit status used to be 2 */
 331               }
 332           }
 333         status = full_write (tape, record_buffer, size);
 334         if (status < 0)
 335           goto ioerror;
 336         goto respond;
 337       }
 338
 339     case 'R':
 340       {
 341         char count_string[STRING_SIZE];
 342         size_t size;
 343
 344         get_string (count_string);
 345         DEBUG1 ("rmtd: R %s\n", count_string);
 346
 347         size = atol (count_string);
 348         prepare_record_buffer (size);
 349         status = full_read (tape, record_buffer, size);
 350         if (status < 0)
 351           goto ioerror;
 352         sprintf (reply_buffer, "A%ld\n", status);
 353         full_write (STDOUT_FILENO, reply_buffer, strlen (reply_buffer));
 354         full_write (STDOUT_FILENO, record_buffer, (size_t) status);
 355         goto top;
 356       }
 357
 358     case 'I':
 359       {
 360         char operation_string[STRING_SIZE];
 361         char count_string[STRING_SIZE];
 362
 363         get_string (operation_string);
 364         get_string  (count_string);
 365         DEBUG2 ("rmtd: I %s %s\n", operation_string, count_string);
 366
 367 #ifdef MTIOCTOP
 368         {
 369           struct mtop mtop;
 370           const char *p;
 371           off_t count = 0;
 372           int negative;
 373
 374           /* Parse count_string, taking care to check for overflow.
 375              We can't use standard functions,
 376              since off_t might be longer than long.  */
 377
 378           for (p = count_string;  *p == ' ' || *p == '\t';  p++)
 379             continue;
 380
 381           negative = *p == '-';
 382           p += negative || *p == '+';
 383
 384           for (;;)
 385             {
 386               int digit = *p++ - '0';
 387               if (9 < (unsigned) digit)
 388                 break;
 389               else
 390                 {
 391                   off_t c10 = 10 * count;
 392                   off_t nc = negative ? c10 - digit : c10 + digit;
 393                   if (c10 / 10 != count || (negative ? c10 < nc : nc < c10))
 394                     {
 395                       report_error_message (N_("Seek offset out of range"));
 396                       exit (EXIT_FAILURE);
 397                     }
 398                   count = nc;
 399                 }
 400             }
 401
 402           mtop.mt_count = count;
 403           if (mtop.mt_count != count)
 404             {
 405               report_error_message (N_("Seek offset out of range"));
 406               exit (EXIT_FAILURE);
 407             }
 408           mtop.mt_op = atoi (operation_string);
 409
 410           if (ioctl (tape, MTIOCTOP, (char *) &mtop) < 0)
 411             goto ioerror;
 412         }
 413 #endif
 414         goto respond;
 415       }
 416
 417     case 'S':                   /* status */
 418       {
 419         DEBUG ("rmtd: S\n");
 420
 421 #ifdef MTIOCGET
 422         {
 423           struct mtget operation;
 424
 425           if (ioctl (tape, MTIOCGET, (char *) &operation) < 0)
 426             goto ioerror;
 427           status = sizeof (operation);
 428           sprintf (reply_buffer, "A%ld\n", status);
 429           full_write (STDOUT_FILENO, reply_buffer, strlen (reply_buffer));
 430           full_write (STDOUT_FILENO, (char *) &operation, sizeof (operation));
 431         }
 432 #endif
 433         goto top;
 434       }
 435
 436     default:
 437       DEBUG1 (_("rmtd: Garbage command %c\n"), command);
 438
 439       report_error_message (N_("Garbage command"));
 440       exit (EXIT_FAILURE);      /* exit status used to be 3 */
 441     }
 442
 443 respond:
 444   DEBUG1 ("rmtd: A %ld\n", status);
 445
 446   sprintf (reply_buffer, "A%ld\n", status);
 447   full_write (STDOUT_FILENO, reply_buffer, strlen (reply_buffer));
 448   goto top;
 449
 450 ioerror:
 451   report_numbered_error (errno);
 452   goto top;
 453 }