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, Version 1.0 only 6 * (the "License"). You may not use this file except in compliance 7 * with the License. 8 * 9 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE 10 * or http://www.opensolaris.org/os/licensing. 11 * See the License for the specific language governing permissions 12 * and limitations under the License. 13 * 14 * When distributing Covered Code, include this CDDL HEADER in each 15 * file and include the License file at usr/src/OPENSOLARIS.LICENSE. 16 * If applicable, add the following below this CDDL HEADER, with the 17 * fields enclosed by brackets "[]" replaced with your own identifying 18 * information: Portions Copyright [yyyy] [name of copyright owner] 19 * 20 * CDDL HEADER END 21 */ 22 /* Copyright (c) 1984, 1986, 1987, 1988, 1989 AT&T */ 23 /* All Rights Reserved */ 24 25 /* Copyright 2004 Sun Microsystems, Inc. All rights reserved. */ 26 /* Use is subject to license terms. */ 27 28 #pragma ident "%Z%%M% %I% %E% SMI" 29 30 /* 31 * uudecode [-o outfile | -p] [input] 32 * 33 * create the specified file, decoding as you go. 34 * used with uuencode. 35 */ 36 #include <unistd.h> 37 #include <stdio.h> 38 #include <stdlib.h> 39 #include <pwd.h> 40 #include <string.h> 41 #include <strings.h> 42 #include <sys/types.h> 43 #include <sys/stat.h> 44 #include <locale.h> 45 #include <nl_types.h> 46 #include <langinfo.h> 47 #include <iconv.h> 48 #include <limits.h> 49 #include <errno.h> 50 #include <ctype.h> 51 #include <signal.h> 52 #include <stdarg.h> 53 54 #define BUFSIZE 90 /* must be a multiple of 3 */ 55 56 #define TABLE_SIZE 0x40 57 58 #define isvalid(octet) (octet <= 0x40) 59 60 /* 61 * base64 decoding table 62 */ 63 /* BEGIN CSTYLED */ 64 static char base64tab[] = { 65 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', 66 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', 67 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', 68 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', 69 '\377', '\377', '\377', '\377', '\377', '\377', '\377', '\377', 70 '\377', '\377', '\377', 62, '\377', '\377', '\377', 63, 71 52, 53, 54, 55, 56, 57, 58, 59, 72 60, 61, '\377', '\377', '\377', '\377', '\377', '\377', 73 '\377', 0, 1, 2, 3, 4, 5, 6, 74 7, 8, 9, 10, 11, 12, 13, 14, 75 15, 16, 17, 18, 19, 20, 21, 22, 76 23, 24, 25, '\377', '\377', '\377', '\377', '\377', 77 '\377', 26, 27, 28, 29, 30, 31, 32, 78 33, 34, 35, 36, 37, 38, 39, 40, 79 41, 42, 43, 44, 45, 46, 47, 48, 80 49, 50, 51, '\377', '\377', '\377', '\377', '\377' 81 }; 82 /* END CSTYLED */ 83 84 static char decode_table[UCHAR_MAX + 1]; 85 86 /* DEC is the basic 1 character decoding function (historical algorithm) */ 87 #define DEC(c) decode_table[c] 88 89 /* true if the character is in the base64 encoding table */ 90 #define validbase64(c) (('A' <= (c) && (c) <= 'Z') || \ 91 ('a' <= (c) && (c) <= 'z') || \ 92 ('0' <= (c) && (c) <= '9') || \ 93 (c) == '+' || (c) == '/') 94 95 static void decode(FILE *, FILE *, int); 96 static int outdec(unsigned char *, unsigned char *, int); 97 static int outdec64(unsigned char *, unsigned char *, int); 98 99 /* from usr/src/cmd/chmod/common.c */ 100 101 void errmsg(int severity, int code, char *format, ...); 102 103 extern mode_t newmode(char *ms, mode_t new_mode, mode_t umsk, 104 char *file, char *path); 105 106 static char *prog; 107 static char outfile[PATH_MAX]; 108 static int mode_err = 0; /* mode conversion error flag */ 109 110 int 111 main(int argc, char **argv) 112 { 113 FILE *in, *out; 114 int pipeout = 0; 115 int oflag = 0; 116 int i; 117 mode_t mode, p_umask; 118 char dest[PATH_MAX]; 119 char modebits[1024]; 120 char buf[LINE_MAX]; 121 int c, errflag = 0; 122 struct stat sbuf; 123 int base64flag = 0; 124 125 prog = argv[0]; 126 (void) signal(SIGPIPE, SIG_DFL); 127 bzero(dest, sizeof (dest)); 128 outfile[0] = '\0'; 129 130 /* Set locale environment variables local definitions */ 131 (void) setlocale(LC_ALL, ""); 132 #if !defined(TEXT_DOMAIN) /* Should be defined by cc -D */ 133 #define TEXT_DOMAIN "SYS_TEST" /* Use this only if it wasn't */ 134 #endif 135 (void) textdomain(TEXT_DOMAIN); 136 p_umask = umask((mode_t)0); 137 138 while ((c = getopt(argc, argv, "o:p")) != EOF) { 139 switch (c) { 140 case 'o': 141 oflag++; 142 (void) strncpy(outfile, optarg, sizeof (outfile)); 143 break; 144 case 'p': 145 pipeout++; 146 break; 147 default: 148 case '?': 149 errflag++; 150 break; 151 } 152 } 153 argc -= optind; 154 argv = &argv[optind]; 155 156 /* optional input arg */ 157 if (argc > 0) { 158 if ((in = fopen(*argv, "r")) == NULL) { 159 perror(*argv); 160 exit(1); 161 } 162 argv++; argc--; 163 } else { 164 in = stdin; 165 errno = 0; 166 if (fstat(fileno(in), &sbuf) < 0) { 167 perror("stdin"); 168 exit(1); 169 } 170 } 171 172 if ((argc > 0) || errflag || (oflag && pipeout)) { 173 (void) fprintf(stderr, 174 gettext("Usage: %s [-o outfile | -p] [infile]\n"), prog); 175 exit(2); 176 } 177 178 /* search for header line */ 179 for (;;) { 180 if (fgets(buf, sizeof (buf), in) == NULL) { 181 /* suppress message if we printed a mode error */ 182 if (mode_err == 0) 183 (void) fprintf(stderr, 184 gettext("No begin line\n")); 185 exit(3); 186 } 187 /* 188 * the check for begin-base64 obviously needs to come 189 * first, since both algorithms' begin strings start 190 * with 'begin'. Also verify that there is a valid 191 * octal or symbolic file mode. 192 */ 193 if (strncmp(buf, "begin-base64", 12) == 0) { 194 base64flag = 1; 195 mode_err = 0; 196 if ((sscanf(buf + 13, "%1023s %1023s", 197 modebits, dest) == 2) && 198 ((sscanf(modebits, "%lo", &mode) == 1) || 199 ((mode = newmode(modebits, 0, p_umask, 200 "", "")) != 0) && mode_err == 0)) 201 break; 202 } else if (strncmp(buf, "begin", 5) == 0) { 203 base64flag = 0; 204 mode_err = 0; 205 if ((sscanf(buf + 6, "%1023s %1023s", 206 modebits, dest) == 2) && 207 ((sscanf(modebits, "%lo", &mode) == 1) || 208 ((mode = newmode(modebits, 0, p_umask, 209 "", "")) != 0) && mode_err == 0)) 210 break; 211 } 212 } 213 214 /* 215 * Now that we know the type of encoding used, we can 216 * initialize the decode table. 217 */ 218 if (base64flag == 0) { 219 (void) memset(decode_table, 0xFF, sizeof (decode_table)); 220 for (i = 0; i <= TABLE_SIZE; i++) 221 decode_table[(unsigned char)i + 0x20] = 222 (unsigned char)i & 0x3F; 223 } else 224 (void) memcpy(decode_table, base64tab, sizeof (base64tab)); 225 226 /* 227 * Filename specified on the command line with -o 228 * overrides filename in the encoded file. 229 */ 230 if (outfile[0] != '\0') 231 (void) strncpy(dest, outfile, sizeof (dest)); 232 233 if (pipeout || 234 (dest[0] == '-' && dest[1] == '\0' && outfile[0] == '\0')) { 235 out = stdout; 236 bzero(outfile, sizeof (outfile)); 237 bzero(dest, sizeof (dest)); 238 } else { 239 /* handle ~user/file format */ 240 if (dest[0] == '~') { 241 char *sl; 242 struct passwd *user; 243 char dnbuf[100]; 244 245 sl = strchr(dest, '/'); 246 if (sl == NULL) { 247 (void) fprintf(stderr, 248 gettext("Illegal ~user\n")); 249 exit(3); 250 } 251 *sl++ = 0; 252 user = getpwnam(dest+1); 253 if (user == NULL) { 254 (void) fprintf(stderr, 255 gettext("No such user as %s\n"), dest); 256 exit(4); 257 } 258 (void) strncpy(dnbuf, user->pw_dir, sizeof (dnbuf)); 259 (void) strlcat(dnbuf, "/", sizeof (dnbuf)); 260 (void) strlcat(dnbuf, sl, sizeof (dnbuf)); 261 (void) strncpy(dest, dnbuf, sizeof (dest)); 262 } 263 } 264 /* if not using stdout, create file */ 265 if (dest[0] != '\0') { 266 if ((out = fopen(dest, "w")) == NULL) { 267 perror(dest); 268 exit(4); 269 } 270 (void) chmod(dest, mode & 0777); 271 } 272 273 decode(in, out, base64flag); 274 275 if (fclose(out) == EOF) { 276 perror(prog); 277 exit(6); 278 } 279 280 return (0); 281 } 282 283 /* 284 * copy from in to out, decoding as you go along. 285 */ 286 287 static void 288 decode(FILE *in, FILE *out, int base64) 289 { 290 char inbuf[120], *ibp, *iptr; 291 unsigned char outbuf[BUFSIZE], *obp, *optr; 292 int n, octets, warned, endseen, numbase64chars; 293 unsigned char chr[4], curchr, ch; 294 longlong_t line; 295 296 if (! base64) { /* use historical algorithm */ 297 warned = 0; 298 for (line = 1; ; line++) { 299 /* for each input line */ 300 if (fgets(inbuf, sizeof (inbuf), in) == NULL) { 301 (void) fprintf(stderr, 302 gettext("No end line\n")); 303 exit(5); 304 } 305 306 /* Is line == 'end\n'? */ 307 if (strcmp(inbuf, "end\n") == 0) { 308 break; 309 } 310 311 n = DEC(inbuf[0]); 312 313 if (n < 0) 314 continue; 315 316 /* 317 * Decode data lines. 318 * 319 * Note that uuencode/uudecode uses only the portable 320 * character set for encoded data and the portable 321 * character set characters must be represented in 322 * a single byte. We use this knowledge to reuse 323 * buffer space while decoding. 324 */ 325 octets = n; 326 obp = (unsigned char *) &inbuf[0]; 327 ibp = &inbuf[1]; 328 while (octets > 0) { 329 if ((ch = outdec((unsigned char *)obp, 330 (unsigned char *)ibp, octets)) 331 != 0x20) { 332 /* invalid characters where detected */ 333 if (!warned) { 334 warned = 1; 335 (void) fprintf(stderr, 336 gettext("Invalid character" 337 " (0x%x) on line" 338 " %lld\n"), ch, line); 339 } 340 break; 341 } 342 ibp += 4; 343 obp += 3; 344 octets -= 3; 345 } 346 /* 347 * Only write out uncorrupted lines 348 */ 349 if (octets <= 0) { 350 (void) fwrite(inbuf, n, 1, out); 351 } 352 } 353 } else { /* use base64 algorithm */ 354 endseen = numbase64chars = 0; 355 optr = outbuf; 356 while ((fgets(inbuf, sizeof (inbuf), in)) != NULL) { 357 /* process an input line */ 358 iptr = inbuf; 359 while ((curchr = *(iptr++)) != NULL) { 360 /* decode chars */ 361 if (curchr == '=') /* if end */ 362 endseen++; 363 364 if (validbase64(curchr)) 365 chr[numbase64chars++] = curchr; 366 /* 367 * if we've gathered 4 base64 octets 368 * we need to decode and output them 369 */ 370 if (numbase64chars == 4) { 371 /*LINTED*/ 372 if (optr - outbuf > BUFSIZE - 3) { 373 (void) fwrite(outbuf, 374 /*LINTED*/ 375 (size_t)(optr - outbuf), 376 1, out); 377 if (ferror(out)) { 378 perror(prog); 379 exit(6); 380 } 381 optr = outbuf; 382 } 383 octets = outdec64(optr, chr, 4); 384 optr += octets; 385 numbase64chars = 0; 386 } 387 } 388 /* 389 * handle any remaining base64 octets at end 390 */ 391 if (endseen && numbase64chars > 0) { 392 octets = outdec64(optr, chr, numbase64chars); 393 optr += octets; 394 numbase64chars = 0; 395 } 396 } 397 /* 398 * if we have generated any additional output 399 * in the buffer, write it out 400 */ 401 if (optr != outbuf) { 402 /*LINTED*/ 403 (void) fwrite(outbuf, (size_t)(optr - outbuf), 404 1, out); 405 if (ferror(out)) { 406 perror(prog); 407 exit(6); 408 } 409 } 410 411 if (endseen == 0) { 412 (void) fprintf(stderr, gettext("No end line\n")); 413 exit(5); 414 } 415 } 416 } 417 418 /* 419 * historical algorithm 420 * 421 * output a group of 3 bytes (4 input characters). 422 * the input chars are pointed to by p, they are to 423 * be output to file f. n is used to tell us not to 424 * output all of them at the end of the file. 425 */ 426 427 static int 428 outdec(unsigned char *out, unsigned char *in, int n) 429 { 430 unsigned char b0 = DEC(*(in++)); 431 unsigned char b1 = DEC(*(in++)); 432 unsigned char b2 = DEC(*(in++)); 433 unsigned char b3 = DEC(*in); 434 435 if (!isvalid(b0)) { 436 return (*(in-3)); 437 } 438 if (!isvalid(b1)) { 439 return (*(in-2)); 440 } 441 442 *(out++) = (b0 << 2) | (b1 >> 4); 443 444 if (n >= 2) { 445 if (!isvalid(b2)) { 446 return (*(in - 1)); 447 } 448 449 *(out++) = (b1 << 4) | (b2 >> 2); 450 451 if (n >= 3) { 452 if (!isvalid(b3)) { 453 return (*in); 454 } 455 *out = (b2 << 6) | b3; 456 } 457 } 458 return (0x20); /* a know good value */ 459 } 460 461 /* 462 * base64 algorithm 463 * 464 * Takes a pointer to the current position in the output buffer, 465 * a pointer to the (up to) 4 byte base64 input buffer and a 466 * count of the number of valid input bytes. 467 * 468 * Return the number of bytes placed in the output buffer 469 */ 470 static int 471 outdec64(unsigned char *out, unsigned char *chr, int num) 472 { 473 474 unsigned char char1, char2, char3, char4; 475 unsigned char *outptr = out; 476 int rc = 0; 477 478 switch (num) { 479 case 0: 480 case 1: /* these are impossible */ 481 default: 482 break; 483 case 2: /* 2 base64 bytes == 1 decoded byte */ 484 char1 = base64tab[chr[0]] & 0xFF; 485 char2 = base64tab[chr[1]] & 0xFF; 486 *(outptr++) = ((char1 << 2) & 0xFC) | 487 ((char2 >> 4) & 0x03); 488 rc = 1; 489 break; 490 case 3: /* 3 base64 bytes == 2 decoded bytes */ 491 char1 = base64tab[chr[0]] & 0xFF; 492 char2 = base64tab[chr[1]] & 0xFF; 493 char3 = base64tab[chr[2]] & 0xFF; 494 *(outptr++) = ((char1 << 2) & 0xFC) | 495 ((char2 >> 4) & 0x03); 496 *(outptr++) = ((char2 << 4) & 0xF0) | 497 ((char3 >> 2) & 0x0F); 498 rc = 2; 499 break; 500 case 4: /* 4 base64 bytes == 3 decoded bytes */ 501 char1 = base64tab[chr[0]] & 0xFF; 502 char2 = base64tab[chr[1]] & 0xFF; 503 char3 = base64tab[chr[2]] & 0xFF; 504 char4 = base64tab[chr[3]] & 0xFF; 505 *(outptr++) = ((char1 << 2) & 0xFC) | 506 ((char2 >> 4) & 0x03); 507 *(outptr++) = ((char2 << 4) & 0xF0) | 508 ((char3 >> 2) & 0x0F); 509 *(outptr++) = ((char3 << 6) & 0xC0) | 510 (char4 & 0x3F); 511 rc = 3; 512 break; 513 } 514 return (rc); 515 } 516 517 /* 518 * error message routine called by newmode. 519 * 520 * The severity and code are ignored here. If this routine gets 521 * called, we set a global flag (which can be tested after return 522 * from here) which tells us whether or not a valid mode has been 523 * parsed or if we printed an error message. 524 */ 525 526 /*ARGSUSED*/ 527 void 528 errmsg(int severity, int code, char *format, ...) 529 { 530 va_list ap; 531 532 va_start(ap, format); 533 534 (void) fprintf(stderr, "uudecode: "); 535 (void) fprintf(stderr, format, ap); 536 537 va_end(ap); 538 539 mode_err = 1; 540 } 541