vos/corelibs/typechain/handlers/type_base64.cc

Go to the documentation of this file.

/* $Id: type_base64.cc,v 1.12 2003/05/29 23:24:47 reed Exp $ */

/** @file type_base64.cc
    Defines type handler class for base64-encoded data.
    Based on public domain code by John Walker, modified for use on C++ strings, rather than files. (should try streams sometime?)
    @author Reed Hedges 12/01
*/

/*
    Copyright (C) 2001, 2002 Reed Hedges <reed@zerohour.net>

    This library is free software; you can redistribute it and/or
    modify it under the terms of the GNU Lesser General Public
    License as published by the Free Software Foundation; either
    version 2 of the License, or (at your option) any later version.

    This library is distributed in the hope that it will be useful,
    but WITHOUT ANY WARRANTY; without even the implied warranty of
    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    Lesser General Public License for more details.

    You should have received a copy of the GNU Lesser General Public
    License along with this library; if not, write to the Free Software
    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307  USA
*/


#include "type_base64.hh"


/*  Comment from top of base64 code on which this Type handler is based:

       Encode or decode file as MIME base64 (RFC 1341)

            by John Walker
            http://www.fourmilab.ch/

            11th August 1997

        This program is in the public domain.

        Permission to use, copy, modify, and distribute this software and its
        documentation for any purpose and without fee is hereby granted,
        without any conditions or restrictions.  This software is provided ``as
        is'' without express or implied warranty.

    Modified by Reed Hedges <reed@zerohour.net> for C++ and strings. 12/18/01

*/

#include <stdio.h>


/* Called when loaded as shared library */

extern "C" void plugin_init(void *param) {
    void (*registerHandler)(TypeHandler* handler) = (void (*)(TypeHandler*))param;
    registerHandler(new TypeBase64());
}




/* Constructor */

TypeBase64::TypeBase64() : TypeHandler("base64", "b64") {

    /* use \n as end of line delimiter */
    eol = "\n";

    /* turn error reporting (stderr) on */
    errcheck = 1;


    /* create magic decoding table */
    int i;
    for (i = 0; i < 255; i++) {
    dtable[i] = 0x80;
    }
    for (i = 'A'; i <= 'Z'; i++) {
        dtable[i] = 0 + (i - 'A');
    }
    for (i = 'a'; i <= 'z'; i++) {
        dtable[i] = 26 + (i - 'a');
    }
    for (i = '0'; i <= '9'; i++) {
        dtable[i] = 52 + (i - '0');
    }
    dtable['+'] = 62;
    dtable['/'] = 63;
    dtable['='] = 0;
}

/*  Decode base64.  */

void TypeBase64::decode(string& data, TypeParams& params)
{

    string newdata("");
    int i;
    long count = 0;
    string::const_iterator s;

    fprintf(stderr, "Base64: decoding...\n");

    for(s = data.begin(); s != data.end();) {

        byte a[4],  // chunk of input data
            b[4],   // corrsponding entries from dtable
            o[3];   // chunk of decoded output data

        for (i = 0; i < 4; i++) {

            // check for premature end of data
            if (s == data.end()) {
                if (errcheck && (i > 0)) {
                    fprintf(stderr, "TypeBase64: Input file incomplete.\n");
                }
                data = newdata;
                return;
            }

            int c;
            // get next 'significant' character from data
            do {
                c = (*s);
                s++;
                if(s == data.end()) {
                    data = newdata;
                    return;
                    // THIS IS BAD-- LAST CHAR WILL BE SKIPPED -- 
                    // THOUGH LAST CHAR SHOULD BE = OR \n ANYWAY.
                }
            } while( c <= ' ' );

            count++;


            if (dtable[c] & 0x80) {
                if (errcheck) {
                    fprintf(stderr, "TypeBase64: Illegal character '%c' in input file.\n", c);
                    data = newdata;
                    return;
                }
                /* Ignoring errors: discard invalid character. */
                i--;
                continue;
            }
            a[i] = (byte) c;
            b[i] = (byte) dtable[c];
        }
        o[0] = (b[0] << 2) | (b[1] >> 4);
        o[1] = (b[1] << 4) | (b[2] >> 2);
        o[2] = (b[2] << 6) | b[3];
        newdata += string((char*)o, 3);
        //fprintf(stderr, "Base64: [%ld] original chunk=%c%c%c%c.  dcorresponding decoding values=%i,%i,%i,%i.  new chunk = \"%s\"\n", count , a[0], a[1], a[2], a[3], b[0], b[1], b[2], b[3], o);

        if (i < 3) {
            fprintf(stderr, "TypeBase64: end of data, but no '=' ??\n");
            data = newdata;
            return;
        }
    }
    fprintf(stderr, "Base64: done.\n");
    data = newdata;
}





/*  ENCODE  --  Encode binary file into base64.  */


int inchar() {
    // jw had this get next char from input stream/buffer
    return EOF;
}
int ochar(int c) {
    //jw had this print char to output file
    putchar(c);
    return 1;
}

void TypeBase64::encode(string& data, TypeParams& params)
{
    return;

    // XXX XXX TODO TODO XXX XXX TODO TODO XXX XXX
    
    int i, hiteof = 0;

    /*  Fill dtable with character encodings.  */

    for (i = 0; i < 26; i++) {
        dtable[i] = 'A' + i;
        dtable[26 + i] = 'a' + i;
    }
    for (i = 0; i < 10; i++) {
        dtable[52 + i] = '0' + i;
    }
    dtable[62] = '+';
    dtable[63] = '/';

    while (!hiteof) {
    byte igroup[3], ogroup[4];
    int c, n;

    igroup[0] = igroup[1] = igroup[2] = 0;
    for (n = 0; n < 3; n++) {
        c = inchar();
        if (c == EOF) {
        hiteof = 1;
        break;
        }
        igroup[n] = (byte) c;
    }
    if (n > 0) {
        ogroup[0] = dtable[igroup[0] >> 2];
        ogroup[1] = dtable[((igroup[0] & 3) << 4) | (igroup[1] >> 4)];
        ogroup[2] = dtable[((igroup[1] & 0xF) << 2) | (igroup[2] >> 6)];
        ogroup[3] = dtable[igroup[2] & 0x3F];

            /* Replace characters in output stream with "=" pad
           characters if fewer than three characters were
           read from the end of the input stream. */

        if (n < 3) {
                ogroup[3] = '=';
        if (n < 2) {
                    ogroup[2] = '=';
        }
        }
        for (i = 0; i < 4; i++) {
        ochar(ogroup[i]);
        }
    }
    }
    if (fputs(eol, stdout) == EOF) {
        exit(1);
    }

}

---