ermyth/include/base64.h

/*
 * $Id: base64.h,v 1.2 2007-07-11 15:08:53 pippijn Exp $
 */
/* base64.h - base64 enc algorithm */

#ifndef BASE64_H
#define BASE64_H

#include <cstddef>

namespace base64
{
  class encoder
  {
    enum step
    {
      step_a, step_b, step_c
    };
    
    struct state
    {
      enum step step;
      char result;
      int stepcnt;
    };
    
    static size_t enc_block (char const * const text, size_t inlen, char *code, state *st);
    static size_t enc_blockend (char *code, state *st);
    
    static size_t const CHARS_PER_LINE = 72;
    
    static char enc_value (char val)
    {
      static char const * const enc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
      if (val > 63)
        return '=';
      return enc[(size_t) val];
    }
    
    state m_state;
    size_t m_bufsize;
    
    size_t enc_end (char *outtext)
    {
      return enc_blockend (outtext, &m_state);
    }

  public:
    encoder (size_t bufsize = 4096)
    : m_bufsize (bufsize)
    {
    }

    size_t encode (char val)
    {
      return enc_value (val);
    }

    size_t encode (char const * const code, size_t const inlen, char *outtext)
    {
      return enc_block (code, inlen, outtext, &m_state);
    }

    bool encode (char const * const code, size_t const inlen, char **outtext)
    {
      size_t outlen = 1 + (((inlen + 2) / 3) * 4);
      if (inlen > outlen)
        {
          *outtext = NULL;
          return 0;
        }

      *outtext = new char[outlen];

      if (*outtext)
        encode (code, inlen, *outtext);

      return outlen - 1;
    }
  };

  class decoder
  {
    enum step
    {
      step_a, step_b, step_c, step_d
    };
    
    struct state
    {
      enum step step;
      char plainchar;
    };
    
    static size_t dec_block (char const * const code, size_t const inlen, char *outtext, state *st);
    
    static size_t dec_value (char val)
    {
      static char const dec[] = {
        62, -1, -1, -1, 63, 52, 53, 54, 55, 56,
        57, 58, 59, 60, 61, -1, -1, -1, -2, -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
      };
      
      static char const decsize = sizeof (dec);
      
      val -= 43;
      if (val < 0 || val > decsize)
        return -1;
      return dec[(size_t) val];
    }
    
    state m_state;
    size_t m_bufsize;
    
  public:
    decoder (size_t bufsize = 4096)
    : m_bufsize (bufsize)
    {
    }

    size_t decode (char val)
    {
      return dec_value (val);
    }

    size_t decode (char const * const code, size_t const inlen, char *outtext)
    {
      return dec_block (code, inlen, outtext, &m_state);
    }

    bool decode (char const * const code, size_t const inlen, char **outtext, size_t *outlen)
    {
      size_t needlen = 3 * (inlen / 4) + 3;
      *outtext = new char[needlen];
      if (!*outtext)
        return false;

      if (!decode (code, inlen, *outtext))
        {
          delete[] *outtext;
          *outtext = NULL;
          return false;
        }

      (*outtext)[needlen] = '\0';
      if (outlen)
        *outlen = needlen;

      return true;
    }
  };
} // namespace base64

#endif // BASE64_H
Revision:	1.1
Committed:	Thu Jul 19 08:24:50 2007 UTC (16 years, 10 months ago) by pippijn
Content type:	text/plain
Branch:	MAIN
Log Message:	initial import. the most important changes since Atheme are: - fixed many memory leaks - fixed many bugs - converted to C++ and use more STL containers - added a (not very enhanced yet) perl module - greatly improved XML-RPC speed - added a JSON-RPC module with code from json-cpp - added a valgrind memcheck module to operserv - added a more object oriented base64 implementation - added a specialised unit test framework - improved stability - use gettimeofday() if available - reworked adding/removing commands - MemoServ IGNORE DEL can now remove indices
#	User	Rev	Content
1	pippijn	1.1	/*
2			* $Id: base64.h,v 1.2 2007-07-11 15:08:53 pippijn Exp $
3			*/
4			/* base64.h - base64 enc algorithm */
5
6			#ifndef BASE64_H
7			#define BASE64_H
8
9			#include <cstddef>
10
11			namespace base64
12			{
13			class encoder
14			{
15			enum step
16			{
17			step_a, step_b, step_c
18			};
19
20			struct state
21			{
22			enum step step;
23			char result;
24			int stepcnt;
25			};
26
27			static size_t enc_block (char const * const text, size_t inlen, char code, state st);
28			static size_t enc_blockend (char code, state st);
29
30			static size_t const CHARS_PER_LINE = 72;
31
32			static char enc_value (char val)
33			{
34			static char const * const enc = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
35			if (val > 63)
36			return '=';
37			return enc[(size_t) val];
38			}
39
40			state m_state;
41			size_t m_bufsize;
42
43			size_t enc_end (char *outtext)
44			{
45			return enc_blockend (outtext, &m_state);
46			}
47
48			public:
49			encoder (size_t bufsize = 4096)
50			: m_bufsize (bufsize)
51			{
52			}
53
54			size_t encode (char val)
55			{
56			return enc_value (val);
57			}
58
59			size_t encode (char const * const code, size_t const inlen, char *outtext)
60			{
61			return enc_block (code, inlen, outtext, &m_state);
62			}
63
64			bool encode (char const * const code, size_t const inlen, char **outtext)
65			{
66			size_t outlen = 1 + (((inlen + 2) / 3) * 4);
67			if (inlen > outlen)
68			{
69			*outtext = NULL;
70			return 0;
71			}
72
73			*outtext = new char[outlen];
74
75			if (*outtext)
76			encode (code, inlen, *outtext);
77
78			return outlen - 1;
79			}
80			};
81
82			class decoder
83			{
84			enum step
85			{
86			step_a, step_b, step_c, step_d
87			};
88
89			struct state
90			{
91			enum step step;
92			char plainchar;
93			};
94
95			static size_t dec_block (char const * const code, size_t const inlen, char outtext, state st);
96
97			static size_t dec_value (char val)
98			{
99			static char const dec[] = {
100			62, -1, -1, -1, 63, 52, 53, 54, 55, 56,
101			57, 58, 59, 60, 61, -1, -1, -1, -2, -1,
102			-1, -1, 0, 1, 2, 3, 4, 5, 6, 7,
103			8, 9, 10, 11, 12, 13, 14, 15, 16, 17,
104			18, 19, 20, 21, 22, 23, 24, 25, -1, -1,
105			-1, -1, -1, -1, 26, 27, 28, 29, 30, 31,
106			32, 33, 34, 35, 36, 37, 38, 39, 40, 41,
107			42, 43, 44, 45, 46, 47, 48, 49, 50, 51
108			};
109
110			static char const decsize = sizeof (dec);
111
112			val -= 43;
113			if (val < 0 \|\| val > decsize)
114			return -1;
115			return dec[(size_t) val];
116			}
117
118			state m_state;
119			size_t m_bufsize;
120
121			public:
122			decoder (size_t bufsize = 4096)
123			: m_bufsize (bufsize)
124			{
125			}
126
127			size_t decode (char val)
128			{
129			return dec_value (val);
130			}
131
132			size_t decode (char const * const code, size_t const inlen, char *outtext)
133			{
134			return dec_block (code, inlen, outtext, &m_state);
135			}
136
137			bool decode (char const * const code, size_t const inlen, char *outtext, size_t outlen)
138			{
139			size_t needlen = 3 * (inlen / 4) + 3;
140			*outtext = new char[needlen];
141			if (!*outtext)
142			return false;
143
144			if (!decode (code, inlen, *outtext))
145			{
146			delete[] *outtext;
147			*outtext = NULL;
148			return false;
149			}
150
151			(*outtext)[needlen] = '\0';
152			if (outlen)
153			*outlen = needlen;
154
155			return true;
156			}
157			};
158			} // namespace base64
159
160			#endif // BASE64_H