[BACK]Return to uuencode.c CVS log [TXT][DIR] Up to [local] / src / usr.bin / uuencode

Diff for /src/usr.bin/uuencode/uuencode.c between version 1.6 and 1.7

version 1.6, 2003/06/10 22:20:53 version 1.7, 2004/04/09 22:54:02
Line 1 
Line 1 
 /*      $OpenBSD$       */  /*      $OpenBSD$       */
 /*      $NetBSD: uuencode.c,v 1.7 1994/11/17 07:41:15 jtc Exp $ */  /*      $FreeBSD: uuencode.c,v 1.18 2004/01/22 07:23:35 grehan Exp $    */
   
 /*-  /*-
  * Copyright (c) 1983, 1993   * Copyright (c) 1983, 1993
Line 30 
Line 30 
  * SUCH DAMAGE.   * SUCH DAMAGE.
  */   */
   
 char copyright[] =  #ifndef lint
   static const char copyright[] =
 "@(#) Copyright (c) 1983, 1993\n\  "@(#) Copyright (c) 1983, 1993\n\
         The Regents of the University of California.  All rights reserved.\n";          The Regents of the University of California.  All rights reserved.\n";
   #endif /* not lint */
   
 #ifndef lint  #ifndef lint
 #if 0  #if 0
 static char sccsid[] = "@(#)uuencode.c  8.2 (Berkeley) 4/2/94";  static const char sccsid[] = "@(#)uuencode.c    8.2 (Berkeley) 4/2/94";
 #endif  #endif
 static char rcsid[] = "$OpenBSD$";  static const char rcsid[] = "$OpenBSD$";
 #endif /* not lint */  #endif /* not lint */
   
 /*  /*
  * uuencode [input] output  
  *  
  * Encode a file so it can be mailed to a remote system.   * Encode a file so it can be mailed to a remote system.
  */   */
   
   #include <sys/param.h>
   #include <sys/socket.h>
   #include <sys/stat.h>
   
   #include <netinet/in.h>
   
   #include <err.h>
   #include <locale.h>
   #include <resolv.h>
 #include <stdio.h>  #include <stdio.h>
 #include <stdlib.h>  #include <stdlib.h>
 #include <string.h>  #include <string.h>
 #include <locale.h>  
 #include <errno.h>  
 #include <sys/types.h>  
 #include <sys/stat.h>  
 #include <unistd.h>  #include <unistd.h>
   
 static void encode(void);  void encode(void);
 static __dead void usage(void);  void base64_encode(void);
   static void usage(void);
   
   FILE *output;
   int mode;
   char **av;
   
 int  int
 main(int argc, char *argv[])  main(int argc, char *argv[])
 {  {
         struct stat sb;          struct stat sb;
         int mode;          int base64;
           int ch;
           char *outfile;
           extern char *__progname;
   
         setlocale(LC_ALL, "");          base64 = 0;
           outfile = NULL;
   
         while (getopt(argc, argv, "") != -1)          if (strcmp(__progname, "b64encode") == 0)
                 usage();                  base64 = 1;
   
           setlocale(LC_ALL, "");
           while ((ch = getopt(argc, argv, "mo:")) != -1) {
                   switch (ch) {
                   case 'm':
                           base64 = 1;
                           break;
                   case 'o':
                           outfile = optarg;
                           break;
                   case '?':
                   default:
                           usage();
                   }
           }
         argv += optind;          argv += optind;
         argc -= optind;          argc -= optind;
   
         switch(argc) {          switch(argc) {
         case 2:                 /* optional first argument is input file */          case 2:                 /* optional first argument is input file */
                 if (!freopen(*argv, "r", stdin) || fstat(fileno(stdin), &sb)) {                  if (!freopen(*argv, "r", stdin) || fstat(fileno(stdin), &sb))
                         (void)fprintf(stderr, "uuencode: %s: %s.\n",                          err(1, "%s", *argv);
                             *argv, strerror(errno));  
                         exit(1);  
                 }  
 #define RWX     (S_IRWXU|S_IRWXG|S_IRWXO)  #define RWX     (S_IRWXU|S_IRWXG|S_IRWXO)
                 mode = sb.st_mode & RWX;                  mode = sb.st_mode & RWX;
                 ++argv;                  ++argv;
Line 91 
Line 118 
                 usage();                  usage();
         }          }
   
         (void)printf("begin %o %s\n", mode, *argv);          av = argv;
         encode();  
         (void)printf("end\n");          if (outfile != NULL) {
         if (ferror(stdout)) {                  output = fopen(outfile, "w+");
                 (void)fprintf(stderr, "uuencode: write error.\n");                  if (output == NULL)
                 exit(1);                          err(1, "unable to open %s for output", outfile);
         }          } else
                   output = stdout;
           if (base64)
                   base64_encode();
           else
                   encode();
           if (ferror(output))
                   errx(1, "write error");
         exit(0);          exit(0);
 }  }
   
Line 105 
Line 139 
 #define ENC(c) ((c) ? ((c) & 077) + ' ': '`')  #define ENC(c) ((c) ? ((c) & 077) + ' ': '`')
   
 /*  /*
  * copy from in to out, encoding as you go along.   * Copy from in to out, encoding in base64 as you go along.
  */   */
 static void  void
   base64_encode(void)
   {
           /*
            * Output must fit into 80 columns, chunks come in 4, leave 1.
            */
   #define GROUPS  ((80 / 4) - 1)
           unsigned char buf[3];
           char buf2[sizeof(buf) * 2 + 1];
           size_t n;
           int rv, sequence;
   
           sequence = 0;
   
           fprintf(output, "begin-base64 %o %s\n", mode, *av);
           while ((n = fread(buf, 1, sizeof(buf), stdin))) {
                   ++sequence;
                   rv = b64_ntop(buf, n, buf2, (sizeof(buf2) / sizeof(buf2[0])));
                   if (rv == -1)
                           errx(1, "b64_ntop: error encoding base64");
                   fprintf(output, "%s%s", buf2, (sequence % GROUPS) ? "" : "\n");
           }
           if (sequence % GROUPS)
                   fprintf(output, "\n");
           fprintf(output, "====\n");
   }
   
   /*
    * Copy from in to out, encoding as you go along.
    */
   void
 encode(void)  encode(void)
 {  {
         int ch, n;          int ch, n;
         char *p;          char *p;
         char buf[80];          char buf[80];
   
           (void)fprintf(output, "begin %o %s\n", mode, *av);
         while ((n = fread(buf, 1, 45, stdin))) {          while ((n = fread(buf, 1, 45, stdin))) {
                 ch = ENC(n);                  ch = ENC(n);
                 if (putchar(ch) == EOF)                  if (fputc(ch, output) == EOF)
                         break;                          break;
                 for (p = buf; n > 0; n -= 3, p += 3) {                  for (p = buf; n > 0; n -= 3, p += 3) {
                           /* Pad with nulls if not a multiple of 3. */
                           if (n < 3) {
                                   p[2] = '\0';
                                   if (n < 2)
                                           p[1] = '\0';
                           }
                         ch = *p >> 2;                          ch = *p >> 2;
                         ch = ENC(ch);                          ch = ENC(ch);
                         if (putchar(ch) == EOF)                          if (fputc(ch, output) == EOF)
                                 break;                                  break;
                         ch = (*p << 4) & 060 | (p[1] >> 4) & 017;                          ch = ((*p << 4) & 060) | ((p[1] >> 4) & 017);
                         ch = ENC(ch);                          ch = ENC(ch);
                         if (putchar(ch) == EOF)                          if (fputc(ch, output) == EOF)
                                 break;                                  break;
                         ch = (p[1] << 2) & 074 | (p[2] >> 6) & 03;                          ch = ((p[1] << 2) & 074) | ((p[2] >> 6) & 03);
                         ch = ENC(ch);                          ch = ENC(ch);
                         if (putchar(ch) == EOF)                          if (fputc(ch, output) == EOF)
                                 break;                                  break;
                         ch = p[2] & 077;                          ch = p[2] & 077;
                         ch = ENC(ch);                          ch = ENC(ch);
                         if (putchar(ch) == EOF)                          if (fputc(ch, output) == EOF)
                                 break;                                  break;
                 }                  }
                 if (putchar('\n') == EOF)                  if (fputc('\n', output) == EOF)
                         break;                          break;
         }          }
         if (ferror(stdin)) {          if (ferror(stdin))
                 (void)fprintf(stderr, "uuencode: read error.\n");                  errx(1, "read error");
                 exit(1);          (void)fprintf(output, "%c\nend\n", ENC('\0'));
         }  
         ch = ENC('\0');  
         (void)putchar(ch);  
         (void)putchar('\n');  
 }  }
   
 static void  static void
 usage(void)  usage(void)
 {  {
         (void)fprintf(stderr,"usage: uuencode [infile] remotefile\n");          (void)fprintf(stderr,
               "usage: uuencode [-m] [-o outfile] [infile] remotefile\n"
               "       b64encode [-o outfile] [infile] remotefile\n");
         exit(1);          exit(1);
 }  }
Legend:
Removed from v.1.6  
changed lines
  Added in v.1.7