cmd/iconv/iconv_main.c

/*
 * This file and its contents are supplied under the terms of the
 * Common Development and Distribution License ("CDDL"), version 1.0.
 * You may only use this file in accordance with the terms of version
 * 1.0 of the CDDL.
 *
 * A full copy of the text of the CDDL should have accompanied this
 * source.  A copy of the CDDL is also available via the Internet at
 * http://www.illumos.org/license/CDDL.
 */

/*
 * Copyright 2011 Nexenta Systems, Inc.  All rights reserved.
 */

/*
 * iconv(1) command.
 */

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <unistd.h>
#include <errno.h>
#include <limits.h>
#include <iconv.h>
#include <libintl.h>
#include <langinfo.h>
#include <locale.h>
#include "charmap.h"

#include <assert.h>

const char *progname;

char *from_cs;
char *to_cs;
int debug;
int cflag;  /* skip invalid characters */
int sflag;  /* silent */
int lflag;  /* list conversions */

void iconv_file(FILE *, const char *);
extern int list_codesets(void);

iconv_t ich;    /* iconv(3c) lib handle */
size_t (*pconv)(const char **iptr, size_t *ileft,
        char **optr, size_t *oleft);

size_t
lib_iconv(const char **iptr, size_t *ileft, char **optr, size_t *oleft)
{
    return (iconv(ich, iptr, ileft, optr, oleft));
}

void
usage(void)
{
    (void) fprintf(stderr, gettext(
        "usage: %s [-cs] [-f from-codeset] [-t to-codeset] "
        "[file ...]\n"), progname);
    (void) fprintf(stderr, gettext("\t%s -l\n"), progname);
    exit(1);
}

int
main(int argc, char **argv)
{
    FILE *fp;
    char *fslash, *tslash;
    int c;

    yydebug = 0;
    progname = getprogname();

    (void) setlocale(LC_ALL, "");

#if !defined(TEXT_DOMAIN)
#define TEXT_DOMAIN "SYS_TEST"
#endif
    (void) textdomain(TEXT_DOMAIN);

    while ((c = getopt(argc, argv, "cdlsf:t:")) != EOF) {
        switch (c) {
        case 'c':
            cflag++;
            break;
        case 'd':
            debug++;
            break;
        case 'l':
            lflag++;
            break;
        case 's':
            sflag++;
            break;
        case 'f':
            from_cs = optarg;
            break;
        case 't':
            to_cs = optarg;
            break;
        case '?':
            usage();
        }
    }

    if (lflag) {
        if (from_cs != NULL || to_cs != NULL || optind != argc)
            usage();
        exit(list_codesets());
    }

    if (from_cs == NULL)
        from_cs = nl_langinfo(CODESET);
    if (to_cs == NULL)
        to_cs = nl_langinfo(CODESET);

    /*
     * If either "from" or "to" contains a slash,
     * then we're using charmaps.
     */
    fslash = strchr(from_cs, '/');
    tslash = strchr(to_cs, '/');
    if (fslash != NULL || tslash != NULL) {
        charmap_init(to_cs, from_cs);
        pconv = cm_iconv;
        if (debug)
            charmap_dump();
    } else {
        ich = iconv_open(to_cs, from_cs);
        if (ich == ((iconv_t)-1)) {
            switch (errno) {
            case EINVAL:
                (void) fprintf(stderr,
                    _("Not supported %s to %s\n"),
                    from_cs, to_cs);
                break;
            default:
                (void) fprintf(stderr,
                    _("iconv_open failed: %s\n"),
                    strerror(errno));
                break;
            }
            exit(1);
        }
        pconv = lib_iconv;
    }

    if (optind == argc ||
        (optind == argc - 1 && 0 == strcmp(argv[optind], "-"))) {
        iconv_file(stdin, "stdin");
        exit(warnings ? 1 : 0);
    }

    for (; optind < argc; optind++) {
        fp = fopen(argv[optind], "r");
        if (fp == NULL) {
            perror(argv[optind]);
            exit(1);
        }
        iconv_file(fp, argv[optind]);
        (void) fclose(fp);
    }
    exit(warnings ? 1 : 0);
}

/*
 * Conversion buffer sizes:
 *
 * The input buffer has room to prepend one mbs character if needed for
 * handling a left-over at the end of a previous conversion buffer.
 *
 * Conversions may grow or shrink data, so using a larger output buffer
 * to reduce the likelihood of leftover input buffer data in each pass.
 */
#define IBUFSIZ (MB_LEN_MAX + BUFSIZ)
#define OBUFSIZ (2 * BUFSIZ)

void
iconv_file(FILE *fp, const char *fname)
{
    static char ibuf[IBUFSIZ];
    static char obuf[OBUFSIZ];
    const char *iptr;
    char *optr;
    off64_t offset;
    size_t ileft, oleft, ocnt;
    int iconv_errno;
    int nr, nw, rc;

    offset = 0;
    ileft = 0;
    iptr = ibuf + MB_LEN_MAX;

    while ((nr = fread(ibuf+MB_LEN_MAX, 1, BUFSIZ, fp)) > 0) {

        assert(iptr <= ibuf+MB_LEN_MAX);
        assert(ileft <= MB_LEN_MAX);
        ileft += nr;
        offset += nr;

        optr = obuf;
        oleft = OBUFSIZ;

        /*
         * Note: the *pconv function is either iconv(3c) or our
         * private equivalent when using charmaps. Both update
         * ileft, oleft etc. even when conversion stops due to
         * an illegal sequence or whatever, so we need to copy
         * the partially converted buffer even on error.
         */
    iconv_again:
        rc = (*pconv)(&iptr, &ileft, &optr, &oleft);
        iconv_errno = errno;

        ocnt = OBUFSIZ - oleft;
        if (ocnt > 0) {
            nw = fwrite(obuf, 1, ocnt, stdout);
            if (nw != ocnt) {
                perror("fwrite");
                exit(1);
            }
        }
        optr = obuf;
        oleft = OBUFSIZ;

        if (rc == (size_t)-1) {
            switch (iconv_errno) {

            case E2BIG: /* no room in output buffer */
                goto iconv_again;

            case EINVAL:    /* incomplete sequence on input */
                if (debug) {
                    (void) fprintf(stderr,
            _("Incomplete sequence in %s at offset %lld\n"),
                        fname, offset - ileft);
                }
                /*
                 * Copy the remainder to the space reserved
                 * at the start of the input buffer.
                 */
                assert(ileft > 0);
                if (ileft <= MB_LEN_MAX) {
                    char *p = ibuf+MB_LEN_MAX-ileft;
                    (void) memmove(p, iptr, ileft);
                    iptr = p;
                    continue; /* read again */
                }
                /*
                 * Should not see ileft > MB_LEN_MAX,
                 * but if we do, handle as EILSEQ.
                 */
                /* FALLTHROUGH */

            case EILSEQ:    /* invalid sequence on input */
                if (!sflag) {
                    (void) fprintf(stderr,
            _("Illegal sequence in %s at offset %lld\n"),
                        fname, offset - ileft);
                    (void) fprintf(stderr,
            _("bad seq: \\x%02x\\x%02x\\x%02x\n"),
                        iptr[0] & 0xff,
                        iptr[1] & 0xff,
                        iptr[2] & 0xff);
                }
                assert(ileft > 0);
                /* skip one */
                iptr++;
                ileft--;
                assert(oleft > 0);
                if (!cflag) {
                    *optr++ = '?';
                    oleft--;
                }
                goto iconv_again;

            default:
                (void) fprintf(stderr,
            _("iconv error (%s) in file $s at offset %lld\n"),
                    strerror(iconv_errno), fname,
                    offset - ileft);
                break;
            }
        }

        /* normal iconv return */
        ileft = 0;
        iptr = ibuf + MB_LEN_MAX;
    }

    /*
     * End of file
     * Flush any shift encodings.
     */
    iptr = NULL;
    ileft = 0;
    optr = obuf;
    oleft = OBUFSIZ;
    (*pconv)(&iptr, &ileft, &optr, &oleft);
    ocnt = OBUFSIZ - oleft;
    if (ocnt > 0) {
        nw = fwrite(obuf, 1, ocnt, stdout);
        if (nw != ocnt) {
            perror("fwrite");
            exit(1);
        }
    }
}