Web alhem.net

Base64.cpp

Go to the documentation of this file.

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

This program 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 General Public License for more details.

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

#ifdef _WIN32
#pragma warning(disable:4786)
#endif
#include <stdio.h>
#include <string.h>

#include "Base64.h"


        static char base64vec[128];

        static const unsigned char g_achEncodeTable[64] =
        {
          'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P',
          'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f',
          'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v',
          'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
        };

namespace Cgi {

Base64::Base64(char eq) : m_eqchar(eq)
{
        setupbase64();
}


Base64::~Base64()
{
}


void Base64::setupbase64()
{
        for (char c = 0; c <= 'z'; c++)
        {
                base64vec[ (int)c] = setupdecode(c); // 0..63
        }
}


char Base64::setupdecode(char c)
{
        if (c >= 'a')
                return (char)((c + 26) - 'a');  // 26..51
        if (c >= 'A')
                return (char)(c - 'A');         // 0..25
        if (c >= '0')
                return (char)((c + 52) - '0');  // 52..61
        if (c == '+')
                return 62;              // 62
        if (c == '/')
                return 63;              // 63
        return 0;
}


unsigned char Base64::reverse(char c)
{
        return g_achEncodeTable[(int)c];
}


void Base64::encode(const char *in,char *out)
{
        int i1 = (in[0] >> 2) & 63;
        int i2 = ( ((in[0] & 3) << 4) + ((in[1] >> 4) & 15) ) & 63;
        int i3 = ( ((in[1] & 15) << 2) + ((in[2] >> 6) & 3) ) & 63;
        int i4 = in[2] & 63;

        out[0] = reverse( (char)i1);
        out[1] = reverse( (char)i2);
        out[2] = reverse( (char)i3);
        out[3] = reverse( (char)i4);
}


int Base64::decode(char c)
{
        return base64vec[(int)c];
}


void Base64::decode_string(char *s, unsigned char *output, int &l)
{
        union {
                unsigned long l;
                char s[4];
        } u;

        if (s[2] == m_eqchar)
        {
                l = 1;
                u.l = decode(s[0]) << 18 | decode(s[1]) << 12;

                output[0] = u.s[2];
                output[1] = 0;
                output[2] = 0;
                return;
        }
        else
        if (s[3] == m_eqchar)
        {
                l = 2;
                u.l = decode(s[0]) << 18 | decode(s[1]) << 12 | decode(s[2]) << 6;

                output[0] = u.s[2];
                output[1] = u.s[1];
                output[2] = 0;
                return;
        }
        l = 3;
        u.l = decode(s[0]) << 18 | decode(s[1]) << 12 | decode(s[2]) << 6 | decode(s[3]);

        output[0] = u.s[2];
        output[1] = u.s[1];
        output[2] = u.s[0];
}


void Base64::encode_file(const char *s,const char *outfn)
{
        FILE *fil;
        FILE *fil2;
        int iptr = 0;
        int ptr = 0;
        size_t dv = 0;
        unsigned char c;
        char tmp[4];
        char slask[200];

        slask[76] = 0;  
        
        if ((fil = fopen(s, "rb")) != NULL)
        {
                fil2 = fopen(outfn, "wt");
                fread(&c,1,1,fil);
                while (!feof(fil))
                {
                        tmp[iptr++] = c;
                        if (iptr == 3)
                        {
                                encode(tmp, slask + ptr);
                                ptr += 4;
                                if (ptr == 76)
                                {
                                        fprintf(fil2,"%s\n",slask);
                                        ptr = 0;
                                }
                                iptr = 0;
                                dv++;
                        }
                        fread(&c,1,1,fil);
                }
                fclose(fil);

                if (iptr)
                {
                        int i = iptr;
                        while (iptr < 3)
                                tmp[iptr++] = 0;
                        encode(tmp, slask + ptr);
                        switch (i)
                        {
                        case 1:
                                slask[ptr + 2] = m_eqchar;
                        case 2:
                                slask[ptr + 3] = m_eqchar;
                        }
                        ptr += 4;
                        if (ptr == 76)
                        {
                                fprintf(fil2,"%s\n",slask);
                                ptr = 0;
                        }
                }
                if (ptr)
                {
                        slask[ptr] = 0;
                        fprintf(fil2,"%s\n",slask);
                        ptr = 0;
                }
                fclose(fil2);
        }
}


void Base64::encode64(const char *in,size_t len,std::vector<std::string> &out)
{
        size_t dv = len / 3;
        size_t ptr = 0;
        size_t i;
        char tmp[100];

        tmp[76] = 0;
        for (i = 0; i < dv; i++)
        {
                encode(in + i * 3,tmp + ptr);
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out.push_back( tmp );
                        ptr = 0;
                }
        }
        if (len % 3)
        {
                char slask[3];

                memset(slask,0,3);
                memmove(slask,in + i * 3,len % 3);

                encode(slask,tmp + ptr);
                switch (len % 3)
                {
                case 1:
                        tmp[ptr + 2] = m_eqchar;
                case 2:
                        tmp[ptr + 3] = m_eqchar;
                }
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out.push_back( tmp );
                        ptr = 0;
                }
        }
        if (ptr)
        {
                tmp[ptr] = 0;
                out.push_back( tmp );
                ptr = 0;
        }
}


std::string Base64::encode_buffer(const std::string& buf)
{
        const char *in = buf.c_str();
        size_t len = buf.size();
        std::string out;
        size_t dv = len / 3;
        size_t ptr = 0;
        size_t i;
        char tmp[100];

        tmp[76] = 0;
        for (i = 0; i < dv; i++)
        {
                encode(in + i * 3,tmp + ptr);
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out += tmp;
                        ptr = 0;
                }
        }
        if (len % 3)
        {
                char slask[3];

                memset(slask,0,3);
                memmove(slask,in + i * 3,len % 3);

                encode(slask,tmp + ptr);
                switch (len % 3)
                {
                case 1:
                        tmp[ptr + 2] = m_eqchar;
                case 2:
                        tmp[ptr + 3] = m_eqchar;
                }
                ptr += 4;
                tmp[ptr] = 0;
                if (ptr == 76)
                {
                        out += tmp;
                        ptr = 0;
                }
        }
        if (ptr)
        {
                tmp[ptr] = 0;
                out += tmp;
                ptr = 0;
        }
        return out;
}


void Base64::encode_from_file(const char *fn,std::vector<std::string> &out)
{
        FILE *fil;
        int iptr = 0;
        int ptr = 0;
        size_t dv = 0;
        unsigned char c;
        char tmp[4];
        char slask[200];

        slask[76] = 0;  
        
        if ((fil = fopen(fn, "rb")) != NULL)
        {
                fread(&c,1,1,fil);
                while (!feof(fil))
                {
                        tmp[iptr++] = c;
                        if (iptr == 3)
                        {
                                encode(tmp, slask + ptr);
                                ptr += 4;
                                if (ptr == 76)
                                {
                                        out.push_back( slask );
                                        ptr = 0;
                                }
                                iptr = 0;
                                dv++;
                        }
                        fread(&c,1,1,fil);
                }
                fclose(fil);

                if (iptr)
                {
                        int i = iptr;
                        while (iptr < 3)
                                tmp[iptr++] = 0;
                        encode(tmp, slask + ptr);
                        switch (i)
                        {
                        case 1:
                                slask[ptr + 2] = m_eqchar;
                        case 2:
                                slask[ptr + 3] = m_eqchar;
                        }
                        ptr += 4;
                        if (ptr == 76)
                        {
                                out.push_back( slask );
                                ptr = 0;
                        }
                }
                if (ptr)
                {
                        slask[ptr] = 0;
                        out.push_back( slask );
                        ptr = 0;
                }
        }
}


void Base64::decode_file(char *s,char *outfn)
{
        FILE *fil;
        FILE *fil2;
        char slask[200];
        unsigned char output[200];

        if ((fil = fopen(s, "rt")) != NULL)
        {
                fil2 = fopen(outfn, "wb");
                fgets(slask, 200, fil);
                while (!feof(fil))
                {
                        while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
                        {
                                slask[strlen(slask) - 1] = 0;
                        }
                        for (int i = 0; i < (int)strlen(slask); i += 4)
                        {
                                int l;
                                decode_string(slask + i, output, l);
                                fwrite(output, 1, l, fil2);
                        }
                        //
                        fgets(slask, 200, fil);
                }
                fclose(fil);
                fclose(fil2);
        }
}


void Base64::decode_to_file(std::vector<std::string> &body,char *outfn)
{
        FILE *fil;
        unsigned char out[4];

        if ((fil = fopen(outfn,"wb")) != NULL)
        {
                for (std::vector<std::string>::iterator it = body.begin(); it != body.end(); it++)
                {
                        for (size_t i = 0; i < (*it).size(); i += 4)
                        {
                                int l;
                                decode_string( (char *)(*it).c_str() + i, out, l);
                                fwrite(out, 1, l, fil);
                        }
                }
                fclose(fil);
        }
}


void Base64::decode_stdout(char *s,FILE *fil2)
{
        FILE *fil;
        char slask[200];
        unsigned char output[200];

        if ((fil = fopen(s, "rt")) != NULL)
        {
                fgets(slask, 200, fil);
                while (!feof(fil))
                {
                        while (strlen(slask) && (slask[strlen(slask) - 1] == 13 || slask[strlen(slask) - 1] == 10))
                        {
                                slask[strlen(slask) - 1] = 0;
                        }
                        for (int i = 0; i < (int)strlen(slask); i += 4)
                        {
                                int l;
                                decode_string(slask + i, output, l);
                                fwrite(output, 1, l, fil2);
                        }
                        //
                        fgets(slask, 200, fil);
                }
                fclose(fil);
        }
}


void Base64::decode_to_stdout(const std::string &str,FILE *fil2)
{
        size_t p = 0;
        char slask[20000];
        unsigned char output[200];

        while (p < str.size())
        {
                size_t i = 0;
                while (str[p] != 13 && str[p] != 10 && p < str.size())
                {
                        slask[i++] = str[p++];
                }
                slask[i] = 0;
                while (str[p] == 13 || str[p] == 10)
                        p++;
                for (i = 0; i < strlen(slask); i += 4)
                {
                        int l;
                        decode_string(slask + i, output, l);
                        fwrite(output, 1, l, fil2);
                }
        }
}


void Base64::decode_to_stdout(std::vector<std::string> &body,FILE *fil)
{
        unsigned char out[4];

        for (std::vector<std::string>::iterator it = body.begin(); it != body.end(); it++)
        {
                for (size_t i = 0; i < (*it).size(); i += 4)
                {
                        int l;
                        decode_string( (char *)(*it).c_str() + i, out, l);
                        fwrite(out, 1, l, fil);
                }
        }
}


size_t Base64::decode_length(const std::string &str)
{
        size_t p = 0;
        size_t len = 0;
        char slask[20000];
        unsigned char output[200];

        while (p < str.size())
        {
                size_t i = 0;
                while (str[p] != 13 && str[p] != 10 && p < str.size())
                {
                        slask[i++] = str[p++];
                }
                slask[i] = 0;
                while (str[p] == 13 || str[p] == 10)
                        p++;
                for (i = 0; i < strlen(slask); i += 4)
                {
                        int l;
                        decode_string(slask + i, output, l);
//                      fwrite(output, 1, l, fil2);
                        len += l;
                }
        }
        return len;
}


void Base64::decode_to_buffer(const std::string& str,char *ut,size_t max)
{
        size_t p = 0;
        size_t o = 0;
        char slask[20000];
        unsigned char output[200];

        while (p < str.size())
        {
                size_t i = 0;
                while (str[p] != 13 && str[p] != 10 && p < str.size())
                {
                        slask[i++] = str[p++];
                }
                slask[i] = 0;
                while (str[p] == 13 || str[p] == 10)
                        p++;
                for (i = 0; i < strlen(slask); i += 4)
                {
                        int l;
                        decode_string(slask + i, output, l);
                        if (o + l <= max)
                        {
                                memcpy(ut + o, output, l);
                                if (o + l < max)
                                        memset(ut + o + l, 0, 1);
                        }
                        o += l;
                }
        }
}



} // namespace

---

Page, code, and content Copyright (C) 2004 by Anders Hedström