C++ Base64 Class

/* ***********************************************
 *                                                *
 * CBase64.h                                    *
 * Base 64 de- and encoding class                *
 *                                                *
 * ============================================ *
 *                                                *
 * This class was written on 28.05.2003            *
 * by Jan Raddatz [jan-raddatz@web.de]            *
 *                                                *
 * ============================================ *
 *                                                *
 * Copyright (c) by Jan Raddatz                    *
 * This class was published @ codeguru.com        *
 * 28.05.2003                                    *
 *                                                *
 *********************************************** */

#pragma once

#include  < afx.h >
#include  < stdlib.h >
#include  < math.h >
#include  < memory.h >
const   static  unsigned  int  MAX_LINE_LENGTH  =   76 ;

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

const   static   char  BASE64_DEALPHABET [ 128 ]  =  
    {
      0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,  //    0 -   9
      0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,  //   10 -  19
      0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,  //   20 -  29
      0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,  //   30 -  39
      0 ,   0 ,   0 ,  62 ,   0 ,   0 ,   0 ,  63 ,  52 ,  53 ,  //   40 -  49
     54 ,  55 ,  56 ,  57 ,  58 ,  59 ,  60 ,  61 ,   0 ,   0 ,  //   50 -  59
      0 ,  61 ,   0 ,   0 ,   0 ,   0 ,   1 ,   2 ,   3 ,   4 ,  //   60 -  69
      5 ,   6 ,   7 ,   8 ,   9 ,  10 ,  11 ,  12 ,  13 ,  14 ,  //   70 -  79
     15 ,  16 ,  17 ,  18 ,  19 ,  20 ,  21 ,  22 ,  23 ,  24 ,  //   80 -  89
     25 ,   0 ,   0 ,   0 ,   0 ,   0 ,   0 ,  26 ,  27 ,  28 ,  //   90 -  99
     29 ,  30 ,  31 ,  32 ,  33 ,  34 ,  35 ,  36 ,  37 ,  38 ,  //  100 - 109
     39 ,  40 ,  41 ,  42 ,  43 ,  44 ,  45 ,  46 ,  47 ,  48 ,  //  110 - 119
     49 ,  50 ,  51 ,   0 ,   0 ,   0 ,   0 ,   0              //  120 - 127
    };

enum
    {
    UNABLE_TO_OPEN_INPUT_FILE,
    UNABLE_TO_OPEN_OUTPUT_FILE,
    UNABLE_TO_CREATE_OUTPUTBUFFER
    };

class  CBase64
    {
     public :
        CBase64 ();

        unsigned  int  CalculateRecquiredEncodeOutputBufferSize (unsigned  int  p_InputByteCount);
        unsigned  int  CalculateRecquiredDecodeOutputBufferSize ( char *  p_pInputBufferString);

         void             EncodeByteTriple  ( char *  p_pInputBuffer, unsigned  int  InputCharacters,  char *  p_pOutputBuffer);
        unsigned  int     DecodeByteQuartet ( char *  p_pInputBuffer,  char *  p_pOutputBuffer);

         void             EncodeBuffer ( char *  p_pInputBuffer, unsigned  int  p_InputBufferLength,  char * p_pOutputBufferString);
        unsigned  int     DecodeBuffer ( char *  p_pInputBufferString,  char *  p_pOutputBuffer);

        unsigned  int  CreateMatchingEncodingBuffer (unsigned  int  p_InputByteCount,  char **  p_ppEncodingBuffer);
        unsigned  int  CreateMatchingDecodingBuffer ( char *  p_pInputBufferString,  char **  p_ppDecodingBuffer);

        unsigned  int  EncodeFile ( char *  p_pSourceFileName,  char *  p_pEncodedFileName);
        unsigned  int  DecodeFile ( char *  p_pSourceFileName,  char *  p_pDecodedFileName);
    };

/* ***********************************************
 *                                                *
 * CBase64.cpp                                    *
 * Base 64 de- and encoding class                *
 *                                                *
 * ============================================ *
 *                                                *
 * This class was written on 28.05.2003            *
 * by Jan Raddatz [jan-raddatz@web.de]            *
 *                                                *
 * ============================================ *
 *                                                *
 * Copyright (c) by Jan Raddatz                    *
 * This class was published @ codeguru.com        *
 * 28.05.2003                                    *
 *                                                *
 *********************************************** */

#include  " CBase64.h "


CBase64::CBase64 ()
    {
    }

unsigned  int  CBase64::CalculateRecquiredEncodeOutputBufferSize (unsigned  int  p_InputByteCount)
    {
    div_t result  =  div (p_InputByteCount,  3 );

    unsigned  int  RecquiredBytes  =   0 ;
     if  (result.rem  ==   0 )
        {
         //  Number of encoded characters
        RecquiredBytes  =  result.quot  *   4 ;

         //  CRLF -> "\r\n" each 76 characters
        result  =  div (RecquiredBytes,  76 );
        RecquiredBytes  +=  result.quot  *   2 ;

         //  Terminating null for the Encoded String
        RecquiredBytes  +=   1 ;

         return  RecquiredBytes;
        }
     else
        {
         //  Number of encoded characters
        RecquiredBytes  =  result.quot  *   4   +   4 ;

         //  CRLF -> "\r\n" each 76 characters
        result  =  div (RecquiredBytes,  76 );
        RecquiredBytes  +=  result.quot  *   2 ;

         //  Terminating null for the Encoded String
        RecquiredBytes  +=   1 ;

         return  RecquiredBytes;
        }
    }

unsigned  int  CBase64::CalculateRecquiredDecodeOutputBufferSize ( char *  p_pInputBufferString)
    {
    unsigned  int  BufferLength  =  strlen (p_pInputBufferString);

    div_t result  =  div (BufferLength,  4 );

     if  (p_pInputBufferString [BufferLength  -   1 ]  !=   ' = ' )
        {
         return  result.quot  *   3 ;
        }
     else
        {
         if  (p_pInputBufferString [BufferLength  -   2 ]  ==   ' = ' )
            {
             return  result.quot  *   3   -   2 ;
            }
         else
            {
             return  result.quot  *   3   -   1 ;
            }
        }
    }

void  CBase64::EncodeByteTriple  ( char *  p_pInputBuffer, unsigned  int  InputCharacters,  char *  p_pOutputBuffer)
    {
    unsigned  int  mask  =   0xfc000000 ;
    unsigned  int  buffer  =   0 ;


     char *  temp  =  ( char * )  & buffer;
    temp [ 3 ]  =  p_pInputBuffer [ 0 ];
     if  (InputCharacters  >   1 )
        temp [ 2 ]  =  p_pInputBuffer [ 1 ];
     if  (InputCharacters  >   2 )
        temp [ 1 ]  =  p_pInputBuffer [ 2 ];

     switch  (InputCharacters)
        {
         case   3 :
            {
            p_pOutputBuffer [ 0 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            buffer  =  buffer  <<   6 ;
            p_pOutputBuffer [ 1 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            buffer  =  buffer  <<   6 ;
            p_pOutputBuffer [ 2 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            buffer  =  buffer  <<   6 ;
            p_pOutputBuffer [ 3 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
             break ;
            }
         case   2 :
            {
            p_pOutputBuffer [ 0 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            buffer  =  buffer  <<   6 ;
            p_pOutputBuffer [ 1 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            buffer  =  buffer  <<   6 ;
            p_pOutputBuffer [ 2 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            p_pOutputBuffer [ 3 ]  =   ' = ' ;
             break ;
            }
         case   1 :
            {
            p_pOutputBuffer [ 0 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            buffer  =  buffer  <<   6 ;
            p_pOutputBuffer [ 1 ]  =  BASE64_ALPHABET [(buffer  &  mask)  >>   26 ];
            p_pOutputBuffer [ 2 ]  =   ' = ' ;
            p_pOutputBuffer [ 3 ]  =   ' = ' ;
             break ;
            }
        }
    }

unsigned  int  CBase64::DecodeByteQuartet ( char *  p_pInputBuffer,  char *  p_pOutputBuffer)
    {
    unsigned  int  buffer  =   0 ;

     if  (p_pInputBuffer[ 3 ]  ==   ' = ' )
        {
         if  (p_pInputBuffer[ 2 ]  ==   ' = ' )
            {
            buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 0 ]])  <<   6 ;
            buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 1 ]])  <<   6 ;
            buffer  =  buffer  <<   14 ;

             char *  temp  =  ( char * )  & buffer;
            p_pOutputBuffer [ 0 ]  =  temp [ 3 ];
            
             return   1 ;
            }
         else
            {
            buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 0 ]])  <<   6 ;
            buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 1 ]])  <<   6 ;
            buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 2 ]])  <<   6 ;
            buffer  =  buffer  <<   8 ;

             char *  temp  =  ( char * )  & buffer;
            p_pOutputBuffer [ 0 ]  =  temp [ 3 ];
            p_pOutputBuffer [ 1 ]  =  temp [ 2 ];
            
             return   2 ;
            }
        }
     else
        {
        buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 0 ]])  <<   6 ;
        buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 1 ]])  <<   6 ;
        buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 2 ]])  <<   6 ;
        buffer  =  (buffer  |  BASE64_DEALPHABET [p_pInputBuffer[ 3 ]])  <<   6 ; 
        buffer  =  buffer  <<   2 ;

         char *  temp  =  ( char * )  & buffer;
        p_pOutputBuffer [ 0 ]  =  temp [ 3 ];
        p_pOutputBuffer [ 1 ]  =  temp [ 2 ];
        p_pOutputBuffer [ 2 ]  =  temp [ 1 ];

         return   3 ;
        }

     return   - 1 ;
    }

void  CBase64::EncodeBuffer ( char *  p_pInputBuffer, unsigned  int  p_InputBufferLength,  char *  p_pOutputBufferString)
    {
    unsigned  int  FinishedByteQuartetsPerLine  =   0 ;
    unsigned  int  InputBufferIndex   =   0 ;
    unsigned  int  OutputBufferIndex  =   0 ;

    memset (p_pOutputBufferString,  0 , CalculateRecquiredEncodeOutputBufferSize (p_InputBufferLength));

     while  (InputBufferIndex  <  p_InputBufferLength)
        {
         if  (p_InputBufferLength  -  InputBufferIndex  <=   2 )
            {
            FinishedByteQuartetsPerLine  ++ ;
            EncodeByteTriple (p_pInputBuffer  +  InputBufferIndex, p_InputBufferLength  -  InputBufferIndex, p_pOutputBufferString  +  OutputBufferIndex);
             break ;
            }
         else
            {
            FinishedByteQuartetsPerLine ++ ;
            EncodeByteTriple (p_pInputBuffer  +  InputBufferIndex,  3 , p_pOutputBufferString  +  OutputBufferIndex);
            InputBufferIndex   +=   3 ;
            OutputBufferIndex  +=   4 ;
            }

         if  (FinishedByteQuartetsPerLine  ==   19 )
            {
            p_pOutputBufferString [OutputBufferIndex  ]  =   ' \r ' ;
            p_pOutputBufferString [OutputBufferIndex + 1 ]  =   ' \n ' ;
            p_pOutputBufferString  +=   2 ;
            FinishedByteQuartetsPerLine  =   0 ;
            }
        }
    }

unsigned  int  CBase64::DecodeBuffer ( char *  p_pInputBufferString,  char *  p_pOutputBuffer)
    {
    unsigned  int  InputBufferIndex   =   0 ;
    unsigned  int  OutputBufferIndex  =   0 ;
    unsigned  int  InputBufferLength  =  strlen (p_pInputBufferString);

     char  ByteQuartet [ 4 ];

     while  (InputBufferIndex  <  InputBufferLength)
        {
         for  ( int  i  =   0 ; i  <   4 ; i ++ )
            {
            ByteQuartet [i]  =  p_pInputBufferString [InputBufferIndex];

             //  Ignore all characters except the ones in BASE64_ALPHABET
             if  ((ByteQuartet [i]  >=   48   &&  ByteQuartet [i]  <=    57 )  ||
                (ByteQuartet [i]  >=   65   &&  ByteQuartet [i]  <=    90 )  ||
                (ByteQuartet [i]  >=   97   &&  ByteQuartet [i]  <=   122 )  ||
                 ByteQuartet [i]  ==   ' + '   ||  ByteQuartet [i]  ==   ' / '   ||  ByteQuartet [i]  ==   ' = ' )
                {
                }
             else
                {
                 //  Invalid character
                i -- ;
                }

            InputBufferIndex ++ ;
            }

        OutputBufferIndex  +=  DecodeByteQuartet (ByteQuartet, p_pOutputBuffer  +  OutputBufferIndex);
        }

     //  OutputBufferIndex gives us the next position of the next decoded character
     //  inside our output buffer and thus represents the number of decoded characters
     //  in our buffer.
     return  OutputBufferIndex;
    }

unsigned  int  CBase64::CreateMatchingEncodingBuffer (unsigned  int  p_InputByteCount,  char **  p_ppEncodingBuffer)
    {
    unsigned  int  Size  =  CalculateRecquiredEncodeOutputBufferSize (p_InputByteCount);
    ( * p_ppEncodingBuffer)  =  ( char * ) malloc (Size);
    memset ( * p_ppEncodingBuffer,  0 , Size);
     return  Size;
    }

unsigned  int  CBase64::CreateMatchingDecodingBuffer ( char *  p_pInputBufferString,  char **  p_ppDecodingBuffer)
    {
    unsigned  int  Size  =  CalculateRecquiredDecodeOutputBufferSize (p_pInputBufferString);
    ( * p_ppDecodingBuffer)  =  ( char * ) malloc (Size);
    memset ( * p_ppDecodingBuffer,  0 , Size);
     return  Size;
    }

unsigned  int  CBase64::EncodeFile ( char *  p_pSourceFileName,  char *  p_pEncodedFileName)
    {
    CFile InputFile;
    CFile OutputFile;

     if  ( ! InputFile.Open (p_pSourceFileName, CFile::modeRead))
         return  UNABLE_TO_OPEN_INPUT_FILE;

     if  ( ! OutputFile.Open (p_pEncodedFileName, CFile::modeCreate | CFile::modeWrite))
         return  UNABLE_TO_OPEN_OUTPUT_FILE;

     char  InputBuffer [ 19   *   3 ];
     char *  pOutputBuffer;
    CreateMatchingEncodingBuffer ( sizeof  (InputBuffer),  & pOutputBuffer);

     if  (pOutputBuffer  ==   0 )
         return  UNABLE_TO_CREATE_OUTPUTBUFFER;

    unsigned  int  ReadBytes  =   0 ;
     while  ((ReadBytes  =  InputFile.Read (InputBuffer,  sizeof  (InputBuffer)))  !=   0 )
        {
        EncodeBuffer (InputBuffer, ReadBytes, pOutputBuffer);
        OutputFile.Write (pOutputBuffer, strlen (pOutputBuffer));
        }

    OutputFile.Flush ();
    OutputFile.Close ();
    InputFile.Close  ();

     return   0 ;
    }

unsigned  int  CBase64::DecodeFile ( char *  p_pSourceFileName,  char *  p_pDecodedFileName)
    {
    CStdioFile    InputFile;
    CFile        OutputFile;

     if  ( ! InputFile.Open (p_pSourceFileName, CFile::modeRead))
         return  UNABLE_TO_OPEN_INPUT_FILE;

     if  ( ! OutputFile.Open (p_pDecodedFileName, CFile::modeCreate | CFile::modeWrite))
         return  UNABLE_TO_OPEN_OUTPUT_FILE;

    CString InputBuffer;
     char     OutputBuffer[ 64 ];

    unsigned  int  ReadBytes  =   0 ;
     while  ((ReadBytes  =  InputFile.ReadString (InputBuffer))  !=   0 )
        {
        InputBuffer.Remove ( ' \r ' );
        InputBuffer.Remove ( ' \n ' );
        unsigned  int  DecodedBytes  =  DecodeBuffer ((LPTSTR) (LPCTSTR) InputBuffer, OutputBuffer);
        OutputFile.Write ( & OutputBuffer [ 0 ], DecodedBytes);
        }


    OutputFile.Flush ();
    OutputFile.Close ();
    InputFile.Close  ();

     return   0 ;
    }