cBase64.h

Go to the documentation of this file.

//
//
 
#ifndef _INC_cBase64_H
#define _INC_cBase64_H
#ifndef NO_PRAGMA_ONCE
#pragma once
#endif
 
#include "../GrayLibBase.h"
#include "GrayCore/include/cUnitTestDecl.h"
#include "GrayCore/include/cMem.h"
#include "GrayCore/include/cDebugAssert.h"
 
namespace GrayLib
{
        class cLogProcessor;
 
        struct GRAYLIB_LINK cBase64Coder        // static
        {
                static inline StrLen_t GetTextSizeFromBinarySize(size_t nSizeBin) noexcept // GetEncodeDestSize
                {
                        return (StrLen_t)(((nSizeBin + 2) / 3) * 4); // round up to allow padding it out with ='s
                }
                static inline size_t GetBinarySizeFromTextSize(StrLen_t nLenText) noexcept // GetDecodeDestSize
                {
                        return ((nLenText * 3) / 4);
                }
 
                UNITTEST_FRIEND(cBase64);
        };
 
        struct GRAYLIB_LINK cBase64Char : public cBase64Coder // static
        {
 
                static const char k_chFill = '=';
                static const char k_Encode[65]; // = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 
                static inline char ENC(BYTE b) 
                {
                        ASSERT(b < 64);
                        return k_Encode[b];
                }
                static inline BYTE DEC(char ch) noexcept
                {
                        if (ch >= 'A' && ch <= 'Z')
                                return (ch - 'A');
                        if (ch >= 'a' && ch <= 'z')
                                return (ch - 'a') + 26;
                        if (ch >= '0' && ch <= '9')
                                return (ch - '0') + 52;
                        if (ch == '+')
                                return 62;
                        if (ch == '-')  // alternate +
                                return 62;
                        if (ch == '/')
                                return 63;
                        if (ch == '_')  // alternate
                                return 63;
                        return 64;      // '=' padding char is outside range.
                }
        };
 
        struct GRAYLIB_LINK cUUCodeChar : public cBase64Coder // static
        {
 
                static const char k_chFill = (char)(' ' + 64);  // junk char for padding.
 
                static inline char ENC(BYTE b)
                {
                        ASSERT(b < 64);
                        return(b + ' ');
                }
                static inline BYTE DEC(char ch) noexcept
                {
                        return(ch - ' ');
                }
        };
 
        template < class _TYPE_CH = cUUCodeChar >
        class cBase64CoderT : public _TYPE_CH
        {
 
                typedef _TYPE_CH SUPER_t;       // the character encoder
        public:
                static inline bool IsValidChar(char ch) noexcept
                {
                        return SUPER_t::DEC(ch) < 64 ;
                }
 
                static inline void EncodeBlock(char* pDstText, const BYTE* pSrcBin)
                {
 
                        BYTE s0 = pSrcBin[0];
                        BYTE s1 = pSrcBin[1];
                        BYTE s2 = pSrcBin[2];
 
                        BYTE n = (s0 >> 2);
                        pDstText[0] = SUPER_t::ENC(n);
                        n = ((s0 << 4) & 0x30) | ((s1 >> 4) & 0x0f);
                        pDstText[1] = SUPER_t::ENC(n);
                        n = ((s1 << 2) & 0x3c) | ((s2 >> 6) & 0x03);
                        pDstText[2] = SUPER_t::ENC(n);
                        n = s2 & 0x3f;
                        pDstText[3] = SUPER_t::ENC(n);
                        ASSERT(IsValidChar(pDstText[3]));
                }
 
                static inline void DecodeBlock(BYTE* pDstBin, const char* pSrcText) noexcept
                {
 
                        // ASSERT( IsValidChar(pSrc[0]));
 
                        BYTE a = SUPER_t::DEC(pSrcText[0]);
                        BYTE b = SUPER_t::DEC(pSrcText[1]);
                        pDstBin[0] = (a << 2) | (b >> 4);
                        BYTE c = SUPER_t::DEC(pSrcText[2]);
                        pDstBin[1] = (b << 4) | (c >> 2);
                        BYTE d = SUPER_t::DEC(pSrcText[3]);
                        pDstBin[2] = (c << 6) | d;
                }
 
                static inline void EncodeBlockEnd(char* pDst, const BYTE* pSrc, size_t nSizeLeft)
                {
                        // Encode misaligned stuff at the end.
                        // must pad this special with 0's. translated extra as '=' sm_chFill
                        BYTE tmp[3];
                        cMem::Copy(tmp, pSrc, nSizeLeft);
                        cMem::Zero(tmp + nSizeLeft, 3 - nSizeLeft);
                        EncodeBlock(pDst, tmp);
                        cValArray::FillSize(pDst + (nSizeLeft + 1), 4 - (nSizeLeft + 1), SUPER_t::k_chFill);    // pad out with =
                }
 
                static StrLen_t GRAYCALL Encode(char* pDstText, StrLen_t nLenDstMax, const BYTE* pSrcBin, size_t nSizeSrc);
 
                static size_t GRAYCALL Decode(BYTE* pDstBin, size_t nSizeDst, const char* pSrcText, StrLen_t nLenSrc = -1); 
        };
 
        typedef cBase64CoderT<cBase64Char> cBase64;
        typedef cBase64CoderT<cUUCodeChar> cUUCode;
}
#endif // _INC_cBase64_H