Annotation of embedaddon/libpdel/io/base64.c, revision 1.1
1.1 ! misho 1:
! 2: /*
! 3: * Copyright (c) 2001-2002 Packet Design, LLC.
! 4: * All rights reserved.
! 5: *
! 6: * Subject to the following obligations and disclaimer of warranty,
! 7: * use and redistribution of this software, in source or object code
! 8: * forms, with or without modifications are expressly permitted by
! 9: * Packet Design; provided, however, that:
! 10: *
! 11: * (i) Any and all reproductions of the source or object code
! 12: * must include the copyright notice above and the following
! 13: * disclaimer of warranties; and
! 14: * (ii) No rights are granted, in any manner or form, to use
! 15: * Packet Design trademarks, including the mark "PACKET DESIGN"
! 16: * on advertising, endorsements, or otherwise except as such
! 17: * appears in the above copyright notice or in the software.
! 18: *
! 19: * THIS SOFTWARE IS BEING PROVIDED BY PACKET DESIGN "AS IS", AND
! 20: * TO THE MAXIMUM EXTENT PERMITTED BY LAW, PACKET DESIGN MAKES NO
! 21: * REPRESENTATIONS OR WARRANTIES, EXPRESS OR IMPLIED, REGARDING
! 22: * THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY AND ALL IMPLIED
! 23: * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE,
! 24: * OR NON-INFRINGEMENT. PACKET DESIGN DOES NOT WARRANT, GUARANTEE,
! 25: * OR MAKE ANY REPRESENTATIONS REGARDING THE USE OF, OR THE RESULTS
! 26: * OF THE USE OF THIS SOFTWARE IN TERMS OF ITS CORRECTNESS, ACCURACY,
! 27: * RELIABILITY OR OTHERWISE. IN NO EVENT SHALL PACKET DESIGN BE
! 28: * LIABLE FOR ANY DAMAGES RESULTING FROM OR ARISING OUT OF ANY USE
! 29: * OF THIS SOFTWARE, INCLUDING WITHOUT LIMITATION, ANY DIRECT,
! 30: * INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, PUNITIVE, OR CONSEQUENTIAL
! 31: * DAMAGES, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF
! 32: * USE, DATA OR PROFITS, HOWEVER CAUSED AND UNDER ANY THEORY OF
! 33: * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
! 34: * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF
! 35: * THE USE OF THIS SOFTWARE, EVEN IF PACKET DESIGN IS ADVISED OF
! 36: * THE POSSIBILITY OF SUCH DAMAGE.
! 37: *
! 38: * Author: Archie Cobbs <archie@freebsd.org>
! 39: */
! 40:
! 41: #include <sys/types.h>
! 42: #include <sys/param.h>
! 43:
! 44: #include <assert.h>
! 45: #include <stdio.h>
! 46: #include <stdarg.h>
! 47: #include <string.h>
! 48: #include <errno.h>
! 49: #include <stdlib.h>
! 50: #include <pthread.h>
! 51:
! 52: #include "structs/structs.h"
! 53: #include "structs/type/array.h"
! 54:
! 55: #include "io/base64.h"
! 56: #include "io/filter.h"
! 57: #include "util/typed_mem.h"
! 58:
! 59: /************************************************************************
! 60: BASE 64 ENCODER
! 61: ************************************************************************/
! 62:
! 63: #define ENCODER_MEM_TYPE "base64_encoder"
! 64:
! 65: /* Encoder state */
! 66: struct b64_encoder {
! 67: struct filter filter;
! 68: pthread_mutex_t mutex;
! 69: char *cmap;
! 70: u_char dbuf[3];
! 71: int doff;
! 72: char *obuf;
! 73: int olen;
! 74: int osize;
! 75: u_char done;
! 76: };
! 77:
! 78: /* Internal functions */
! 79: static filter_read_t b64_encoder_read;
! 80: static filter_write_t b64_encoder_write;
! 81: static filter_end_t b64_encoder_end;
! 82: static filter_convert_t b64_encoder_convert;
! 83: static filter_destroy_t b64_encoder_destroy;
! 84:
! 85: static void b64_encoder_encode(struct b64_encoder *enc, char *buf);
! 86: static int b64_encoder_output(struct b64_encoder *enc, const char *buf);
! 87: static int b64_cmap_check(const char *cmap);
! 88:
! 89: /* Public variables */
! 90: const char b64_rfc2045_charset[] =
! 91: "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=";
! 92:
! 93: /*
! 94: * Create a new base-64 encoder with optional custom character set.
! 95: */
! 96: struct filter *
! 97: b64_encoder_create(const char *cmap)
! 98: {
! 99: struct b64_encoder *enc;
! 100:
! 101: /* Default to HTTP charset */
! 102: if (cmap == NULL)
! 103: cmap = b64_rfc2045_charset;
! 104: else if (b64_cmap_check(cmap) == -1)
! 105: return (NULL);
! 106:
! 107: /* Create object */
! 108: if ((enc = MALLOC(ENCODER_MEM_TYPE, sizeof(*enc))) == NULL)
! 109: return (NULL);
! 110: memset(enc, 0, sizeof(*enc));
! 111:
! 112: /* Copy character map */
! 113: if ((enc->cmap = STRDUP(ENCODER_MEM_TYPE, cmap)) == NULL) {
! 114: FREE(ENCODER_MEM_TYPE, enc);
! 115: return (NULL);
! 116: }
! 117:
! 118: /* Create mutex */
! 119: if ((errno = pthread_mutex_init(&enc->mutex, NULL)) != 0) {
! 120: FREE(ENCODER_MEM_TYPE, enc->cmap);
! 121: FREE(ENCODER_MEM_TYPE, enc);
! 122: return (NULL);
! 123: }
! 124:
! 125: /* Set up methods */
! 126: enc->filter.read = b64_encoder_read;
! 127: enc->filter.write = b64_encoder_write;
! 128: enc->filter.end = b64_encoder_end;
! 129: enc->filter.convert = b64_encoder_convert;
! 130: enc->filter.destroy = b64_encoder_destroy;
! 131:
! 132: /* Done */
! 133: return (&enc->filter);
! 134: }
! 135:
! 136: /*
! 137: * Destroy a base 64 encoder.
! 138: */
! 139: void
! 140: b64_encoder_destroy(struct filter **filterp)
! 141: {
! 142: struct b64_encoder **const encp = (struct b64_encoder **)filterp;
! 143: struct b64_encoder *const enc = *encp;
! 144:
! 145: if (enc != NULL) {
! 146: pthread_mutex_destroy(&enc->mutex);
! 147: FREE(ENCODER_MEM_TYPE, enc->cmap);
! 148: FREE(ENCODER_MEM_TYPE, enc->obuf);
! 149: FREE(ENCODER_MEM_TYPE, enc);
! 150: *encp = NULL;
! 151: }
! 152: }
! 153:
! 154: /*
! 155: * Write raw bytes into the encoder.
! 156: */
! 157: int
! 158: b64_encoder_write(struct filter *filter, const void *data, int len)
! 159: {
! 160: struct b64_encoder *const enc = (struct b64_encoder *)filter;
! 161: char buf[4];
! 162: int total;
! 163: int chunk;
! 164: int r;
! 165:
! 166: /* Lock encoder */
! 167: r = pthread_mutex_lock(&enc->mutex);
! 168: assert(r == 0);
! 169:
! 170: /* Check if closed */
! 171: if (enc->done) {
! 172: r = pthread_mutex_unlock(&enc->mutex);
! 173: assert(r == 0);
! 174: errno = EPIPE;
! 175: return (-1);
! 176: }
! 177:
! 178: /* Process bytes */
! 179: for (total = 0; len > 0; total += chunk) {
! 180:
! 181: /* Read in next chunk of raw data */
! 182: chunk = MIN(len, 3 - enc->doff);
! 183: memcpy(enc->dbuf + enc->doff, data, chunk);
! 184: data = (char *)data + chunk;
! 185: len -= chunk;
! 186:
! 187: /* Process data if data buffer full */
! 188: if ((enc->doff += chunk) == 3) {
! 189: b64_encoder_encode(enc, buf);
! 190: if (b64_encoder_output(enc, buf) == -1) {
! 191: total = (total == 0) ? -1 : total;
! 192: break;
! 193: }
! 194: enc->doff = 0;
! 195: }
! 196:
! 197: /* Unlock encoder in case there is a reader */
! 198: r = pthread_mutex_unlock(&enc->mutex);
! 199: assert(r == 0);
! 200: r = pthread_mutex_lock(&enc->mutex);
! 201: assert(r == 0);
! 202: }
! 203:
! 204: /* Done */
! 205: r = pthread_mutex_unlock(&enc->mutex);
! 206: assert(r == 0);
! 207: return (total);
! 208: }
! 209:
! 210: /*
! 211: * Read out encoded data.
! 212: */
! 213: int
! 214: b64_encoder_read(struct filter *filter, void *data, int len)
! 215: {
! 216: struct b64_encoder *const enc = (struct b64_encoder *)filter;
! 217: int r;
! 218:
! 219: r = pthread_mutex_lock(&enc->mutex);
! 220: assert(r == 0);
! 221: len = MIN(len, enc->olen);
! 222: memcpy(data, enc->obuf, len);
! 223: memmove(enc->obuf, enc->obuf + len, enc->olen - len);
! 224: enc->olen -= len;
! 225: r = pthread_mutex_unlock(&enc->mutex);
! 226: assert(r == 0);
! 227: return (len);
! 228: }
! 229:
! 230: /*
! 231: * Mark end of written data.
! 232: */
! 233: int
! 234: b64_encoder_end(struct filter *filter)
! 235: {
! 236: struct b64_encoder *const enc = (struct b64_encoder *)filter;
! 237: char buf[4];
! 238: int r;
! 239:
! 240: /* Lock encoder */
! 241: r = pthread_mutex_lock(&enc->mutex);
! 242: assert(r == 0);
! 243:
! 244: /* Only do this once */
! 245: if (enc->done)
! 246: goto done;
! 247:
! 248: /* Pad with termination character(s) */
! 249: if (enc->doff > 0) {
! 250: memset(enc->dbuf + enc->doff, 0, 3 - enc->doff);
! 251: b64_encoder_encode(enc, buf);
! 252: switch (enc->doff) {
! 253: case 1:
! 254: buf[2] = enc->cmap[64];
! 255: /* fall through */
! 256: case 2:
! 257: buf[3] = enc->cmap[64];
! 258: break;
! 259: }
! 260: if (b64_encoder_output(enc, buf) == -1) {
! 261: r = pthread_mutex_unlock(&enc->mutex);
! 262: assert(r == 0);
! 263: return (-1);
! 264: }
! 265: }
! 266:
! 267: done:
! 268: /* Done */
! 269: enc->done = 1;
! 270: r = pthread_mutex_unlock(&enc->mutex);
! 271: assert(r == 0);
! 272: return (0);
! 273: }
! 274:
! 275: /*
! 276: * Convert byte count to read before and after filter.
! 277: */
! 278: static int
! 279: b64_encoder_convert(struct filter *filter, int num, int forward)
! 280: {
! 281: if (forward)
! 282: return (((num * 4) + 2) / 3);
! 283: else
! 284: return (((num * 3) + 3) / 4);
! 285: }
! 286:
! 287: /*
! 288: * Encode one chunk of data (3 bytes -> 4 characters).
! 289: *
! 290: * This assumes the encoder is locked.
! 291: */
! 292: static void
! 293: b64_encoder_encode(struct b64_encoder *enc, char *buf)
! 294: {
! 295: buf[0] = (enc->dbuf[0] >> 2) & 0x3f;
! 296: buf[0] = enc->cmap[(u_char)buf[0]];
! 297: buf[1] = ((enc->dbuf[0] << 4) & 0x30) | ((enc->dbuf[1] >> 4) & 0x0f);
! 298: buf[1] = enc->cmap[(u_char)buf[1]];
! 299: buf[2] = ((enc->dbuf[1] << 2) & 0x3c) | ((enc->dbuf[2] >> 6) & 0x03);
! 300: buf[2] = enc->cmap[(u_char)buf[2]];
! 301: buf[3] = enc->dbuf[2] & 0x3f;
! 302: buf[3] = enc->cmap[(u_char)buf[3]];
! 303: }
! 304:
! 305: /*
! 306: * Append encoded characters to the output buffer.
! 307: *
! 308: * This assumes the encoder is locked.
! 309: */
! 310: static int
! 311: b64_encoder_output(struct b64_encoder *enc, const char *buf)
! 312: {
! 313: if (enc->olen + 4 > enc->osize) {
! 314: const int new_osize = (enc->olen * 2) + 31;
! 315: char *new_obuf;
! 316:
! 317: if ((new_obuf = REALLOC(ENCODER_MEM_TYPE,
! 318: enc->obuf, new_osize)) == NULL)
! 319: return (-1);
! 320: enc->obuf = new_obuf;
! 321: enc->osize = new_osize;
! 322: }
! 323: memcpy(enc->obuf + enc->olen, buf, 4);
! 324: enc->olen += 4;
! 325: return (0);
! 326: }
! 327:
! 328: /*
! 329: * Sanity check character map.
! 330: */
! 331: static int
! 332: b64_cmap_check(const char *cmap)
! 333: {
! 334: int i;
! 335: int j;
! 336:
! 337: if (strlen(cmap) != 65)
! 338: goto bogus;
! 339: for (i = 0; i < 64; i++) {
! 340: for (j = i + 1; j < 65; j++) {
! 341: if (cmap[i] == cmap[j]) {
! 342: bogus: errno = EINVAL;
! 343: return (-1);
! 344: }
! 345: }
! 346: }
! 347: return (0);
! 348: }
! 349:
! 350: /************************************************************************
! 351: BASE 64 DECODER
! 352: ************************************************************************/
! 353:
! 354: #define DECODER_MEM_TYPE "base64_decoder"
! 355:
! 356: /* Encoder state */
! 357: struct b64_decoder {
! 358: struct filter filter;
! 359: pthread_mutex_t mutex;
! 360: u_char cmap[256];
! 361: u_char cbuf[4];
! 362: int coff;
! 363: u_char *obuf;
! 364: int olen;
! 365: int osize;
! 366: char pad;
! 367: u_char done;
! 368: u_char strict;
! 369: };
! 370:
! 371: /* Internal functions */
! 372: static filter_read_t b64_decoder_read;
! 373: static filter_write_t b64_decoder_write;
! 374: static filter_end_t b64_decoder_end;
! 375: static filter_convert_t b64_decoder_convert;
! 376: static filter_destroy_t b64_decoder_destroy;
! 377:
! 378: static void b64_decoder_decode(struct b64_decoder *dec, u_char *buf);
! 379: static int b64_decoder_output(struct b64_decoder *dec,
! 380: u_char *buf, int len);
! 381:
! 382: /*
! 383: * Create a new base-64 decoder with optional custom character set.
! 384: */
! 385: struct filter *
! 386: b64_decoder_create(const char *cmap, int strict)
! 387: {
! 388: struct b64_decoder *dec;
! 389: const char *s;
! 390: u_char byte;
! 391: int i;
! 392:
! 393: /* Default to HTTP charset */
! 394: if (cmap == NULL)
! 395: cmap = b64_rfc2045_charset;
! 396: else if (b64_cmap_check(cmap) == -1)
! 397: return (NULL);
! 398:
! 399: /* Create object */
! 400: if ((dec = MALLOC(DECODER_MEM_TYPE, sizeof(*dec))) == NULL)
! 401: return (NULL);
! 402: memset(dec, 0, sizeof(*dec));
! 403: dec->strict = !!strict;
! 404: dec->pad = cmap[64];
! 405:
! 406: /* Create mutex */
! 407: if ((errno = pthread_mutex_init(&dec->mutex, NULL)) != 0) {
! 408: FREE(DECODER_MEM_TYPE, dec);
! 409: return (NULL);
! 410: }
! 411:
! 412: /* Create inverse character map */
! 413: memset(dec->cmap, 0xff, sizeof(dec->cmap));
! 414: for (i = 1; i < sizeof(dec->cmap); i++) {
! 415: if ((s = strchr(cmap, (char)i)) != NULL) {
! 416: byte = (u_char)(s - cmap);
! 417: dec->cmap[i] = (byte == 64) ? 0xfe : byte;
! 418: }
! 419: }
! 420:
! 421: /* Set up methods */
! 422: dec->filter.read = b64_decoder_read;
! 423: dec->filter.write = b64_decoder_write;
! 424: dec->filter.end = b64_decoder_end;
! 425: dec->filter.convert = b64_decoder_convert;
! 426: dec->filter.destroy = b64_decoder_destroy;
! 427:
! 428: /* Done */
! 429: return (&dec->filter);
! 430: }
! 431:
! 432: /*
! 433: * Destroy a base 64 decoder.
! 434: */
! 435: void
! 436: b64_decoder_destroy(struct filter **filterp)
! 437: {
! 438: struct b64_decoder **const decp = (struct b64_decoder **)filterp;
! 439: struct b64_decoder *const dec = *decp;
! 440:
! 441: if (dec != NULL) {
! 442: pthread_mutex_destroy(&dec->mutex);
! 443: FREE(DECODER_MEM_TYPE, dec->obuf);
! 444: FREE(DECODER_MEM_TYPE, dec);
! 445: *decp = NULL;
! 446: }
! 447: }
! 448:
! 449: /*
! 450: * Write encoded characters into the decoder.
! 451: */
! 452: int
! 453: b64_decoder_write(struct filter *filter, const void *data, int len)
! 454: {
! 455: struct b64_decoder *const dec = (struct b64_decoder *)filter;
! 456: u_char buf[3];
! 457: int total = 0;
! 458: int r;
! 459:
! 460: /* Lock decoder */
! 461: r = pthread_mutex_lock(&dec->mutex);
! 462: assert(r == 0);
! 463:
! 464: /* Check if closed */
! 465: if (dec->done) {
! 466: r = pthread_mutex_unlock(&dec->mutex);
! 467: assert(r == 0);
! 468: errno = EPIPE;
! 469: return (-1);
! 470: }
! 471:
! 472: /* Process bytes */
! 473: while (total < len) {
! 474:
! 475: /* Fill up input buffer */
! 476: for ( ; dec->coff < 4 && total < len; total++) {
! 477: const u_char val = dec->cmap[((u_char *)data)[total]];
! 478:
! 479: if (val == 0xff) {
! 480: if (dec->strict) {
! 481: errno = EINVAL;
! 482: total = (total == 0) ? -1 : total;
! 483: goto done;
! 484: }
! 485: continue;
! 486: }
! 487: if (val == 0xfe) /* pad char */
! 488: continue;
! 489: assert(val < 64);
! 490: dec->cbuf[dec->coff++] = val;
! 491: }
! 492:
! 493: /* Process characters if character buffer is full */
! 494: if (dec->coff == 4) {
! 495: b64_decoder_decode(dec, buf);
! 496: if (b64_decoder_output(dec, buf, 3) == -1) {
! 497: total = (total == 0) ? -1 : total;
! 498: goto done;
! 499: }
! 500: dec->coff = 0;
! 501: }
! 502:
! 503: /* Take a breather */
! 504: r = pthread_mutex_unlock(&dec->mutex);
! 505: assert(r == 0);
! 506: r = pthread_mutex_lock(&dec->mutex);
! 507: assert(r == 0);
! 508: }
! 509:
! 510: done:
! 511: /* Done */
! 512: r = pthread_mutex_unlock(&dec->mutex);
! 513: assert(r == 0);
! 514: return (total);
! 515: }
! 516:
! 517: /*
! 518: * Read out decoded data.
! 519: */
! 520: int
! 521: b64_decoder_read(struct filter *filter, void *buf, int len)
! 522: {
! 523: struct b64_decoder *const dec = (struct b64_decoder *)filter;
! 524: int r;
! 525:
! 526: r = pthread_mutex_lock(&dec->mutex);
! 527: assert(r == 0);
! 528: len = MIN(len, dec->olen);
! 529: memcpy(buf, dec->obuf, len);
! 530: memmove(dec->obuf, dec->obuf + len, dec->olen - len);
! 531: dec->olen -= len;
! 532: r = pthread_mutex_unlock(&dec->mutex);
! 533: assert(r == 0);
! 534: return (len);
! 535: }
! 536:
! 537: /*
! 538: * Mark end of written data.
! 539: */
! 540: int
! 541: b64_decoder_end(struct filter *filter)
! 542: {
! 543: struct b64_decoder *const dec = (struct b64_decoder *)filter;
! 544: u_char buf[3];
! 545: int len;
! 546: int r;
! 547:
! 548: /* Lock decoder */
! 549: r = pthread_mutex_lock(&dec->mutex);
! 550: assert(r == 0);
! 551:
! 552: /* Only do this once */
! 553: if (dec->done)
! 554: goto done;
! 555:
! 556: /* Spit out any trailing characters */
! 557: if (dec->coff > 0) {
! 558: switch (dec->coff) {
! 559: case 1: /* really not valid */
! 560: case 2:
! 561: len = 1;
! 562: break;
! 563: case 3:
! 564: len = 2;
! 565: break;
! 566: default:
! 567: assert(0);
! 568: len = 0; /* silence gcc warning */
! 569: }
! 570: memset(dec->cbuf + dec->coff, 0, 4 - dec->coff);
! 571: b64_decoder_decode(dec, buf);
! 572: if (b64_decoder_output(dec, buf, len) == -1) {
! 573: r = pthread_mutex_unlock(&dec->mutex);
! 574: assert(r == 0);
! 575: return (-1);
! 576: }
! 577: dec->coff = 0;
! 578: }
! 579:
! 580: done:
! 581: /* Done */
! 582: dec->done = 1;
! 583: r = pthread_mutex_unlock(&dec->mutex);
! 584: assert(r == 0);
! 585: return (0);
! 586: }
! 587:
! 588: /*
! 589: * Convert byte count to read before and after filter.
! 590: */
! 591: static int
! 592: b64_decoder_convert(struct filter *filter, int num, int forward)
! 593: {
! 594: if (forward)
! 595: return (((num * 3) + 3) / 4);
! 596: else
! 597: return (((num * 4) + 2) / 3);
! 598: }
! 599:
! 600: /*
! 601: * Decode one chunk of characters (4 characters -> 3 bytes).
! 602: *
! 603: * This assumes the decoder is locked.
! 604: */
! 605: static void
! 606: b64_decoder_decode(struct b64_decoder *dec, u_char *buf)
! 607: {
! 608: buf[0] = (dec->cbuf[0] << 2) | (dec->cbuf[1] >> 4);
! 609: buf[1] = (dec->cbuf[1] << 4) | (dec->cbuf[2] >> 2);
! 610: buf[2] = (dec->cbuf[2] << 6) | dec->cbuf[3];
! 611: }
! 612:
! 613: /*
! 614: * Append decoded characters to the output buffer.
! 615: *
! 616: * This assumes the decoder is locked.
! 617: */
! 618: static int
! 619: b64_decoder_output(struct b64_decoder *dec, u_char *buf, int len)
! 620: {
! 621: if (dec->olen + len > dec->osize) {
! 622: const int new_osize = (dec->olen * 2) + 31;
! 623: u_char *new_obuf;
! 624:
! 625: if ((new_obuf = REALLOC(DECODER_MEM_TYPE,
! 626: dec->obuf, new_osize)) == NULL)
! 627: return (-1);
! 628: dec->obuf = new_obuf;
! 629: dec->osize = new_osize;
! 630: }
! 631: memcpy(dec->obuf + dec->olen, buf, len);
! 632: dec->olen += len;
! 633: return (0);
! 634: }
! 635:
! 636: #ifdef BASE64_TEST
! 637:
! 638: #include <err.h>
! 639: #include <unistd.h>
! 640:
! 641: int
! 642: main(int ac, char **av)
! 643: {
! 644: struct filter *filter;
! 645: int do_encode = 1; /* default encode */
! 646: int do_input = 1; /* default test input stream */
! 647: int strict = 0;
! 648: char buf[123];
! 649: FILE *input;
! 650: FILE *output;
! 651: int len;
! 652: int ch;
! 653:
! 654: /* Process command line */
! 655: while ((ch = getopt(ac, av, "deiso")) != -1) {
! 656: switch (ch) {
! 657: case 'd': /* decode */
! 658: do_encode = 0;
! 659: break;
! 660: case 'e': /* encode */
! 661: do_encode = 1;
! 662: break;
! 663: case 'i': /* test input stream */
! 664: do_input = 1;
! 665: break;
! 666: case 'o': /* test output stream */
! 667: do_input = 0;
! 668: break;
! 669: case 's': /* enforce strict decoding */
! 670: strict = 1;
! 671: break;
! 672: default:
! 673: usage:
! 674: errx(1, "usage: base64 <-e|-d> <-i|-o> [-s]");
! 675: }
! 676: }
! 677: ac -= optind;
! 678: av += optind;
! 679:
! 680: /* Sanity */
! 681: if (do_input == -1 || do_encode == -1)
! 682: goto usage;
! 683:
! 684: /* Get filter */
! 685: if (do_encode) {
! 686: if ((filter = b64_encoder_create(NULL)) == NULL)
! 687: err(1, "b64_encoder_create");
! 688: } else {
! 689: if ((filter = b64_decoder_create(NULL, strict)) == NULL)
! 690: err(1, "b64_decoder_create");
! 691: }
! 692:
! 693: /* Get filter stream */
! 694: if (do_input) {
! 695: if ((output = filter_fopen(filter, 0, stdout, "w")) == NULL)
! 696: err(1, "filter_fopen");
! 697: input = stdin;
! 698: } else {
! 699: if ((input = filter_fopen(filter, 0, stdin, "r")) == NULL)
! 700: err(1, "filter_fopen");
! 701: output = stdout;
! 702: }
! 703:
! 704: /* Convert */
! 705: while ((len = fread(buf, 1, sizeof(buf), input)) != 0)
! 706: fwrite(buf, 1, len, output);
! 707:
! 708: /* Done */
! 709: fclose(output);
! 710: return (0);
! 711: }
! 712:
! 713: #endif /* BASE64_TEST */
! 714:
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to base64.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / libpdel / io