ibrcommon/ibrcommon/data/Base64Stream.cpp

Go to the documentation of this file.

/*
 * Base64Stream.cpp
 *
 *  Created on: 16.06.2011
 *      Author: morgenro
 */

#include "ibrcommon/data/Base64Stream.h"
#include <sstream>
#include <string.h>

namespace ibrcommon
{
        const char Base64Stream::encodeCharacterTable[65] = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
        const char Base64Stream::decodeCharacterTable[256] = {
        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
        ,-1,62,-1,-1,-1,63,52,53,54,55,56,57,58,59,60,61,-1,-1,-1,-1,-1,-1,-1,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18,19,20,21
        ,22,23,24,25,-1,-1,-1,-1,-1,-1,26,27,28,29,30,31,32,33,34,35,36,37,38,39,40,41,42,43,44,45,46,47,48,49,50,51,-1,-1,-1,-1,-1,
        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
        -1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1
        ,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,-1,
        -1,-1,-1};

        Base64Stream::Base64Stream(std::ostream &stream, bool decode, const size_t linebreak, const size_t buffer)
         : std::ostream(this), _decode(decode), _stream(stream), data_buf_(new char[buffer]), data_size_(buffer), _base64_state(0), _char_counter(0), _base64_padding(0), _linebreak(linebreak)
        {
                setp(data_buf_, data_buf_ + data_size_ - 1);
                _base64_buf[0] = '\0';
                _base64_buf[1] = '\0';
                _base64_buf[2] = '\0';
                _base64_buf[3] = '\0';
        }

        Base64Stream::~Base64Stream()
        {
                delete[] data_buf_;
        }

        int Base64Stream::sync()
        {
                int ret = std::char_traits<char>::eq_int_type(this->overflow(
                                std::char_traits<char>::eof()), std::char_traits<char>::eof()) ? -1
                                : 0;

                if (!_decode && (_base64_state > 0))
                {
                        char buf[4];

                        // fill padding with zeros
                        for (int i = _base64_state; i < 3; i++) _base64_buf[i] = '\0';

                        buf[0] = (_base64_buf[0] & 0xfc) >> 2;
                        buf[1] = ((_base64_buf[0] & 0x03) << 4) + ((_base64_buf[1] & 0xf0) >> 4);
                        buf[2] = ((_base64_buf[1] & 0x0f) << 2) + ((_base64_buf[2] & 0xc0) >> 6);
                        buf[3] = _base64_buf[2] & 0x3f;

                        for (int i = 0; i < (_base64_state+1); i++)
                                _stream << encodeCharacterTable[(int)buf[i]];

                        while(_base64_state++<3) _stream << '=';
                        _base64_state = 0;
                }

                return ret;
        }

        int Base64Stream::overflow(int c)
        {
                char *ibegin = data_buf_;
                char *iend = pptr();

                if (!std::char_traits<char>::eq_int_type(c, std::char_traits<char>::eof()))
                {
                        *iend++ = std::char_traits<char>::to_char_type(c);
                }

                // mark the buffer as free
                setp(data_buf_, data_buf_ + data_size_ - 1);

                // available data
                size_t len = (iend - ibegin);

                // if there is nothing to send, just return
                if (len == 0)
                {
                        return std::char_traits<char>::not_eof(c);
                }

                // do cipher stuff
                if (_decode)
                {
                        for (size_t i = 0; i < len; i++)
                        {
                                // skip newline chars
                                if (ibegin[i] == '\n') continue;

                                // put char into the decode buffer
                                if (ibegin[i] == '=')
                                {
                                        _base64_buf[_base64_state] = decodeCharacterTable[ (int)'\0' ];
                                        _base64_padding++;
                                }
                                else
                                {
                                        _base64_buf[_base64_state] = decodeCharacterTable[ (int)ibegin[i] ];
                                }

                                if (_base64_state == 3)
                                {
                                        _base64_buf[0] = (char)((_base64_buf[0] << 2) + ((_base64_buf[1] & 0x30) >> 4));
                                        _base64_buf[1] = (char)(((_base64_buf[1] & 0xf) << 4) + ((_base64_buf[2] & 0x3c) >> 2));
                                        _base64_buf[2] = (char)(((_base64_buf[2] & 0x3) << 6) + _base64_buf[3]);

                                        for (int j = 0; j < (3 - _base64_padding); j++)
                                        {
                                                _stream << _base64_buf[j];
                                        }

                                        _base64_state = 0;
                                        _base64_padding = 0;
                                }
                                else
                                {
                                        _base64_state++;
                                }
                        }
                }
                else
                {
                        for (size_t i = 0; i < len; i++)
                        {
                                // put char into the encode buffer
                                _base64_buf[_base64_state] = ibegin[i];

                                if (_base64_state == 2)
                                {
                                        _stream << encodeCharacterTable[(_base64_buf[0] & 0xfc) >> 2];
                                        _stream << encodeCharacterTable[((_base64_buf[0] & 0x03) << 4) + ((_base64_buf[1] & 0xf0) >> 4)];
                                        _stream << encodeCharacterTable[((_base64_buf[1] & 0x0f) << 2) + ((_base64_buf[2] & 0xc0) >> 6)];
                                        _stream << encodeCharacterTable[_base64_buf[2] & 0x3f];

                                        _base64_state = 0;
                                        _char_counter += 4;

                                        if (_char_counter >= _linebreak)
                                        {
                                                _stream << '\n';
                                                _char_counter = 0;
                                        }
                                }
                                else
                                {
                                        _base64_state++;
                                }
                        }
                }

                return std::char_traits<char>::not_eof(c);
        }
}