lib/libcodex/code-uu.c

/***********************************************************************
*                                                                      *
*               This software is part of the ast package               *
*          Copyright (c) 2003-2011 AT&T Intellectual Property          *
*                      and is licensed under the                       *
*                 Eclipse Public License, Version 1.0                  *
*                    by AT&T Intellectual Property                     *
*                                                                      *
*                A copy of the License is available at                 *
*          http://www.eclipse.org/org/documents/epl-v10.html           *
*         (with md5 checksum b35adb5213ca9657e911e9befb180842)         *
*                                                                      *
*              Information and Software Systems Research               *
*                            AT&T Research                             *
*                           Florham Park NJ                            *
*                                                                      *
*                 Glenn Fowler <gsf@research.att.com>                  *
*                  David Korn <dgk@research.att.com>                   *
*                   Phong Vo <kpv@research.att.com>                    *
*                                                                      *
***********************************************************************/
#pragma prototyped

/*
 * uuencode familiy coders
 */

#include <codex.h>
#include <ctype.h>

#define UUIN        3
#define UUOUT       4
#define UUCHUNK     15

#define UU_END      (UCHAR_MAX)
#define UU_IGN      (UCHAR_MAX-1)
#define UU_PAD      (UCHAR_MAX-2)

typedef struct
{
    int     pad;
    int     fill;
    int     length;
    const char  map[65];
} Data_t;

typedef struct State_s
{
    Codex_t*    codex;

    const Data_t*   data;

    unsigned char*  bb;
    unsigned char*  bp;
    unsigned char*  bl;
    unsigned char*  be;
    unsigned char*  map;
    unsigned char*  pb;
    unsigned char*  pp;

    int     c1;
    int     c2;
    int     nl;
    int     string;
    int     text;

    unsigned char   mapbuf[UCHAR_MAX + 2];
    unsigned char   buf[SF_BUFSIZE];
    unsigned char   peek[UUIN];
} State_t;

static const Data_t uu_base64 =
{
    '=',
    0,
    0,
    "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
};

static const Data_t uu_bsd =
{
    0,
    0156,
    1,
    "`!\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
};

static const Data_t uu_posix =
{
    0,
    0,
    1,
    " !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"
};

#define GETCHAR(p)      ((p)->bp < (p)->be ? (int)*(p)->bp++ : fill(p))
#define PUTCHAR(p,s,e,c)    ((s<e) ? (*s++=(c)) : (*p->pp++=(c)))

static int
fill(State_t* state)
{
    ssize_t r;

    state->bp = state->buf;
    if ((r = sfrd(state->codex->sp, state->bp, sizeof(state->buf), &state->codex->sfdisc)) <= 0)
    {
        state->be = state->bp;
        return EOF;
    }
    state->be = state->bp + r;
    return *state->bp++;
}

static int
flush(register State_t* state)
{
    uint32_t    b;
    int     c3;
    int     x;

    x = 1;
    if (state->c1 >= 0)
    {
        c3 = state->data->fill;
        x++;
        if (state->c2 < 0)
        {
            state->c2 = c3;
            x++;
        }
        b = (state->c1 << 16) | (state->c2 << 8) | c3;
        *state->bp++ = state->data->map[b >> 18];
        *state->bp++ = state->data->map[(b >> 12) & 077];
        *state->bp++ = x == 3 && state->data->pad ? state->data->pad : state->data->map[(b >> 6) & 077];
        *state->bp++ = state->data->pad ? state->data->pad : state->data->map[b & 077];
        state->c1 = state->c2 = -1;
    }
    if ((state->bl - state->bp) < UUOUT * UUCHUNK || state->bp > state->buf + !!state->bb)
    {
        if (state->bb)
            *state->bb = state->data->map[((state->bp - state->bb - x) / UUOUT) * UUIN + 1];
        if (state->string)
        {
            if (*(state->bp - 1) == '\n')
                state->bp--;
        }
        else
        {
            if (*(state->bp - 1) != '\n')
                *state->bp++ = '\n';
        }
        x = state->bp - state->buf;
        state->bp = state->buf;
        state->bl = state->bp + UUOUT * UUCHUNK;
        if (sfwr(state->codex->sp, state->buf, x, &state->codex->sfdisc) != x)
            return EOF;
    }
    return 0;
}

static int
uu_open(Codex_t* p, char* const args[], Codexnum_t flags)
{
    register State_t*   state;
    register char*      s;
    register char**     a;
    unsigned char*      m;
    unsigned char*      q;
    const Data_t*       data;
    int         c;
    int         n;
    int         string;
    int         text;

    data = &uu_posix;
    string = text = 0;
    a = (char**)args + 1;
    while (s = *++a)
        if (streq(s, "base64") || streq(s, "mime"))
            data = &uu_base64;
        else if (streq(s, "bsd") || streq(s, "ucb"))
            data = &uu_bsd;
        else if (streq(s, "posix"))
            data = &uu_posix;
        else if (streq(s, "string"))
        {
            if (data != &uu_base64)
            {
                if (p->disc->errorf)
                    (*p->disc->errorf)(NiL, p->disc, 2, "%s: %s: option valid for base64/mime only", p->meth->name, s);
                return -1;
            }
            string = 1;
        }
        else if (streq(s, "text"))
            text = 1;
        else
        {
            if (p->disc->errorf)
                (*p->disc->errorf)(NiL, p->disc, 2, "%s: %s: unknown option", p->meth->name, s);
            return -1;
        }
    if (!(state = newof(0, State_t, 1, 0)))
    {
        if (p->disc->errorf)
            (*p->disc->errorf)(NiL, p->disc, 2, "out of space");
        return -1;
    }
    state->data = data;
    state->string = string;
    state->text = text;
    if (p->flags & CODEX_DECODE)
    {
        n = data->length ? 0 : UU_IGN;
        q = state->mapbuf;
        memset(q, n, sizeof(state->mapbuf));
        state->map = ++q;
        q[EOF] = UU_END;
        if (n)
            q[data->pad] = UU_PAD;
        for (m = (unsigned char*)data->map; c = *m; m++)
            q[c] =  m - (unsigned char*)data->map;
    }
    p->data = state;
    state->codex = p;
    return 0;
}

static int
uu_init(Codex_t* p)
{
    register State_t*   state = (State_t*)p->data;
    int         n;

    state->bp = state->buf;
    if (p->flags & CODEX_ENCODE)
    {
        n = UUOUT * UUCHUNK + state->data->length + 1;
        state->be = state->bp + (sizeof(state->buf) / n) * n;
        if (state->data->length)
        {
            state->bb = state->bp;
            *state->bp++ = state->data->map[UUIN * UUCHUNK];
        }
        state->bl = state->bp + UUOUT * UUCHUNK;
        state->c1 = state->c2 = -1;
    }
    else
    {
        state->be = state->bp;
        state->pb = state->pp = state->peek;
        if (state->data->length)
            state->nl = -1;
        state->c1 = state->c2 = -1;
    }
    return 0;
}

static ssize_t
uu_read(Sfio_t* sp, void* buf, size_t n, Sfdisc_t* disc)
{
    register State_t*   state = (State_t*)CODEX(disc)->data;
    register char*      s = (char*)buf;
    register char*      e = s + n;
    register uint32_t   b;
    register int        c;
    register int        x;

    if (state->pb < state->pp)
    {
        while (s < e && state->pb < state->pp)
            *s++ = *state->pb++;
        if (state->pb == state->pp)
            state->pb = state->pp = state->peek;
    }
    if (state->data->length)
        while (s < e)
        {
            switch (c = GETCHAR(state))
            {
            case EOF:
                goto done;
            case '\n':
                state->nl = -1;
                continue;
            }
            if (state->nl < 0)
                state->nl = state->map[c];
            else if (state->nl > 0)
            {
                b = state->map[c];
                if ((c = GETCHAR(state)) == EOF)
                    c = 0;
                else
                    c = state->map[c];
                b = (b << 6) | c;
                if ((c = GETCHAR(state)) == EOF)
                    c = 0;
                else
                    c = state->map[c];
                b = (b << 6) | c;
                if ((c = GETCHAR(state)) == EOF)
                    c = 0;
                else
                    c = state->map[c];
                b = (b << 6) | c;
                if (state->text)
                {
                    if ((c = (b >> 16) & 0xFF) != '\r')
                        PUTCHAR(state, s, e, c);
                    if ((c = (b >> 8) & 0xFF) != '\r')
                        PUTCHAR(state, s, e, c);
                    if ((c = b & 0xFF) != '\r')
                        PUTCHAR(state, s, e, c);
                }
                else
                {
                    PUTCHAR(state, s, e, (b >> 16));
                    PUTCHAR(state, s, e, (b >> 8));
                    PUTCHAR(state, s, e, b);
                }
                if ((state->nl -= 3) < 0)
                    while (state->nl++ < 0)
                        s--;
            }
        }
    else
        while (s < e)
        {
            while ((c = state->map[GETCHAR(state)]) >= 64)
                if (c != UU_IGN)
                    goto done;
            b = c;
            while ((c = state->map[GETCHAR(state)]) >= 64)
                if (c != UU_IGN)
                {
                    if (state->codex->disc->errorf)
                        (*state->codex->disc->errorf)(NiL, state->codex->disc, 1, "%c: extra input character ignored", c);
                    goto done;
                }
            b = (b << 6) | c;
            while ((c = state->map[GETCHAR(state)]) >= 64)
                if (c != UU_IGN)
                {
                    if (state->text)
                    {
                        if ((x = (b >> 4) & 0xFF) != '\r')
                            PUTCHAR(state, s, e, x);
                    }
                    else
                        PUTCHAR(state, s, e, (b >> 4));
                    goto done;
                }
            b = (b << 6) | c;
            while ((c = state->map[GETCHAR(state)]) >= 64)
                if (c != UU_IGN)
                {
                    if (state->text)
                    {
                        if ((x = (b >> 10) & 0xFF) != '\r')
                            PUTCHAR(state, s, e, x);
                        if ((x = (b >> 2) & 0xFF) != '\r')
                            PUTCHAR(state, s, e, x);
                    }
                    else
                    {
                        PUTCHAR(state, s, e, (b >> 10));
                        PUTCHAR(state, s, e, (b >> 2));
                    }
                    goto done;
                }
            b = (b << 6) | c;
            if (state->text)
            {
                if ((x = (b >> 16) & 0xFF) != '\r')
                    PUTCHAR(state, s, e, x);
                if ((x = (b >> 8) & 0xFF) != '\r')
                    PUTCHAR(state, s, e, x);
                if ((x = b & 0xFF) != '\r')
                    PUTCHAR(state, s, e, x);
            }
            else
            {
                PUTCHAR(state, s, e, (b >> 16));
                PUTCHAR(state, s, e, (b >> 8));
                PUTCHAR(state, s, e, b);
            }
        }
 done:
    return s - (char*)buf;
}

static ssize_t
uu_write(Sfio_t* sp, const void* buf, size_t n, Sfdisc_t* disc)
{
    register State_t*   state = (State_t*)CODEX(disc)->data;
    register unsigned char* s;
    register unsigned char* e;
    register uint32_t   b;
    register int        c1;
    register int        c2;
    register int        c3;

    s = (unsigned char*)buf;
    e = s + n;
    if ((c1 = state->c1) >= 0)
    {
        state->c1 = -1;
        if ((c2 = state->c2) >= 0)
        {
            state->c2 = -1;
            goto get_3;
        }
        goto get_2;
    }
    while (s < e)
    {
        do
        {
            if (state->nl)
            {
                state->nl = 0;
                c1 = '\n';
                goto get_2;
            }
            if (s >= e)
                break;
            c1 = *s++;
            if (state->text && c1 == '\n')
            {
                c1 = '\r';
                c2 = '\n';
                goto get_3;
            }
 get_2:
            if (s >= e)
            {
                state->c1 = c1;
                return n;
            }
            c2 = *s++;
            if (state->text && c2 == '\n')
            {
                c2 = '\r';
                c3 = '\n';
                goto put_123;
            }
 get_3:
            if (s >= e)
            {
                state->c1 = c1;
                state->c2 = c2;
                return n;
            }
            c3 = *s++;
            if (state->text && c3 == '\n')
            {
                state->nl = 1;
                c3 = '\r';
            }
 put_123:
            b = (c1 << 16) | (c2 << 8) | c3;
            *state->bp++ = state->data->map[b >> 18];
            *state->bp++ = state->data->map[(b >> 12) & 077];
            *state->bp++ = state->data->map[(b >> 6) & 077];
            *state->bp++ = state->data->map[b & 077];
        } while (state->bp < state->bl);
        if (!state->string)
            *state->bp++ = '\n';
        if (state->bp >= state->be)
        {
            if (sfwr(sp, state->buf, state->bp - state->buf, disc) != (state->bp - state->buf))
                return -1;
            state->bp = state->buf;
        }
        if (state->bb)
        {
            state->bb = state->bp;
            *state->bp++ = state->data->map[UUIN * UUCHUNK];
        }
        state->bl = state->bp + UUOUT * UUCHUNK;
    }
    return n;
}

static int
uu_sync(Codex_t* p)
{
    return (p->flags & CODEX_ENCODE) ? flush((State_t*)p->data) : 0;
}

Codexmeth_t codex_uu =
{
    "uu",
    "uuencode printable encoding.",
    "[+posix?Posix \buuencode\b(1). This is the default.]"
    "[+base64|mime?MIME base64 encoding.]"
    "[+bsd|ucb?BSD \buuencode\b(1).]"
    "[+string?Encode into a string with no separators (base64 only).]"
    "[+text?Encode \\n => \\r\\n, decode \\r\\n => \\n.]"
    "[+(version)?codex-uu (AT&T Research) 2010-01-15]"
    "[+(author)?Glenn Fowler <gsf@research.att.com>]",
    CODEX_DECODE|CODEX_ENCODE|CODEX_UU,
    0,
    0,
    uu_open,
    0,
    uu_init,
    0,
    uu_read,
    uu_write,
    uu_sync,
    0,
    0,
    0,
    0,
    CODEXNEXT(uu)
};

CODEXLIB(uu)