OverSim
base64.h
Go to the documentation of this file.
1 
2 
3 // base64.hpp
4 // Autor Konstantin Pilipchuk
5 // mailto:lostd@ukr.net
6 //
7 //
8 
9 #if !defined(__BASE64_H_INCLUDED__)
10 #define __BASE64_H_INCLUDED__ 1
11 
12 #ifndef MAKEDEPEND
13 # include <iterator>
14 #endif
15 
16 static
17 int _base64Chars[]= {'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',
18  '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',
19  '0','1','2','3','4','5','6','7','8','9',
20  '+','/' };
21 
22 
23 #define _0000_0011 0x03
24 #define _1111_1100 0xFC
25 #define _1111_0000 0xF0
26 #define _0011_0000 0x30
27 #define _0011_1100 0x3C
28 #define _0000_1111 0x0F
29 #define _1100_0000 0xC0
30 #define _0011_1111 0x3F
31 
32 #define _EQUAL_CHAR (-1)
33 #define _UNKNOWN_CHAR (-2)
34 
35 #define _IOS_FAILBIT std::ios_base::failbit
36 #define _IOS_EOFBIT std::ios_base::eofbit
37 #define _IOS_BADBIT std::ios_base::badbit
38 #define _IOS_GOODBIT std::ios_base::goodbit
39 
40 // TEMPLATE CLASS base64_put
41 template<class _E = char, class _Tr = std::char_traits<_E> >
42 class base64
43 {
44 public:
45 
46  typedef unsigned char byte_t;
47  typedef _E char_type;
48  typedef _Tr traits_type;
49 
50  // base64 requires max line length <= 72 characters
51  // you can fill end of line
52  // it may be crlf, crlfsp, noline or other class like it
53 
54 
55  struct crlf
56  {
57  template<class _OI>
58  _OI operator()(_OI _To) const{
59  *_To = _Tr::to_char_type('\r'); ++_To;
60  *_To = _Tr::to_char_type('\n'); ++_To;
61 
62  return (_To);
63  }
64  };
65 
66 
67  struct crlfsp
68  {
69  template<class _OI>
70  _OI operator()(_OI _To) const{
71  *_To = _Tr::to_char_type('\r'); ++_To;
72  *_To = _Tr::to_char_type('\n'); ++_To;
73  *_To = _Tr::to_char_type(' '); ++_To;
74 
75  return (_To);
76  }
77  };
78 
79  struct noline
80  {
81  template<class _OI>
82  _OI operator()(_OI _To) const{
83  return (_To);
84  }
85  };
86 
87  struct three2four
88  {
89  void zero()
90  {
91  _data[0] = 0;
92  _data[1] = 0;
93  _data[2] = 0;
94  }
95 
96  byte_t get_0() const
97  {
98  return _data[0];
99  }
100  byte_t get_1() const
101  {
102  return _data[1];
103  }
104  byte_t get_2() const
105  {
106  return _data[2];
107  }
108 
109  void set_0(byte_t _ch)
110  {
111  _data[0] = _ch;
112  }
113 
114  void set_1(byte_t _ch)
115  {
116  _data[1] = _ch;
117  }
118 
119  void set_2(byte_t _ch)
120  {
121  _data[2] = _ch;
122  }
123 
124  // 0000 0000 1111 1111 2222 2222
125  // xxxx xxxx xxxx xxxx xxxx xxxx
126  // 0000 0011 1111 2222 2233 3333
127 
128  int b64_0() const {return (_data[0] & _1111_1100) >> 2;}
129  int b64_1() const {return ((_data[0] & _0000_0011) << 4) + ((_data[1] & _1111_0000)>>4);}
130  int b64_2() const {return ((_data[1] & _0000_1111) << 2) + ((_data[2] & _1100_0000)>>6);}
131  int b64_3() const {return (_data[2] & _0011_1111);}
132 
133  void b64_0(int _ch) {_data[0] = ((_ch & _0011_1111) << 2) | (_0000_0011 & _data[0]);}
134 
135  void b64_1(int _ch) {
136  _data[0] = ((_ch & _0011_0000) >> 4) | (_1111_1100 & _data[0]);
137  _data[1] = ((_ch & _0000_1111) << 4) | (_0000_1111 & _data[1]); }
138 
139  void b64_2(int _ch) {
140  _data[1] = ((_ch & _0011_1100) >> 2) | (_1111_0000 & _data[1]);
141  _data[2] = ((_ch & _0000_0011) << 6) | (_0011_1111 & _data[2]); }
142 
143  void b64_3(int _ch){
144  _data[2] = (_ch & _0011_1111) | (_1100_0000 & _data[2]);}
145 
146  private:
147  byte_t _data[3];
148 
149  };
150 
151 
152 
153 
154  template<class _II, class _OI, class _State, class _Endline>
155  _II put(_II _First, _II _Last, _OI _To, _State& _St, _Endline _Endl) const
156  {
157  three2four _3to4;
158  int line_octets = 0;
159 
160  while(_First != _Last)
161  {
162  _3to4.zero();
163 
164  // берём по 3 символа
165  _3to4.set_0(*_First);
166  _First++;
167 
168  if(_First == _Last)
169  {
170  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_0()]); ++_To;
171  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_1()]); ++_To;
172  *_To = _Tr::to_char_type('='); ++_To;
173  *_To = _Tr::to_char_type('='); ++_To;
174  goto __end;
175  }
176 
177  _3to4.set_1(*_First);
178  _First++;
179 
180  if(_First == _Last)
181  {
182  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_0()]); ++_To;
183  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_1()]); ++_To;
184  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_2()]); ++_To;
185  *_To = _Tr::to_char_type('='); ++_To;
186  goto __end;
187  }
188 
189  _3to4.set_2(*_First);
190  _First++;
191 
192  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_0()]); ++_To;
193  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_1()]); ++_To;
194  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_2()]); ++_To;
195  *_To = _Tr::to_char_type(_base64Chars[_3to4.b64_3()]); ++_To;
196 
197  if(line_octets == 17) // base64 позволяет длину строки не более 72 символов
198  {
199  //_To = _Endl(_To);
200  *_To = '\n'; ++_To;
201  line_octets = 0;
202  }
203  else
204  ++line_octets;
205  }
206 
207  __end: ;
208 
209  return (_First);
210 
211  }
212 
213 
214  template<class _II, class _OI, class _State>
215  _II get(_II _First, _II _Last, _OI _To, _State& _St) const
216  {
217  three2four _3to4;
218  int _Char;
219 
220  while(_First != _Last)
221  {
222 
223  // Take octet
224  _3to4.zero();
225 
226  // -- 0 --
227  // Search next valid char...
228  while((_Char = _getCharType(*_First)) < 0 && _Char == _UNKNOWN_CHAR)
229  {
230  if(++_First == _Last)
231  {
232  _St |= _IOS_FAILBIT|_IOS_EOFBIT; return _First; // unexpected EOF
233  }
234  }
235 
236  if(_Char == _EQUAL_CHAR){
237  // Error! First character in octet can't be '='
238  _St |= _IOS_FAILBIT;
239  return _First;
240  }
241  else
242  _3to4.b64_0(_Char);
243 
244 
245  // -- 1 --
246  // Search next valid char...
247  while(++_First != _Last)
248  if((_Char = _getCharType(*_First)) != _UNKNOWN_CHAR)
249  break;
250 
251  if(_First == _Last) {
252  _St |= _IOS_FAILBIT|_IOS_EOFBIT; // unexpected EOF
253  return _First;
254  }
255 
256  if(_Char == _EQUAL_CHAR){
257  // Error! Second character in octet can't be '='
258  _St |= _IOS_FAILBIT;
259  return _First;
260  }
261  else
262  _3to4.b64_1(_Char);
263 
264 
265  // -- 2 --
266  // Search next valid char...
267  while(++_First != _Last)
268  if((_Char = _getCharType(*_First)) != _UNKNOWN_CHAR)
269  break;
270 
271  if(_First == _Last) {
272  // Error! Unexpected EOF. Must be '=' or base64 character
273  _St |= _IOS_FAILBIT|_IOS_EOFBIT;
274  return _First;
275  }
276 
277  if(_Char == _EQUAL_CHAR){
278  // OK!
279  _3to4.b64_2(0);
280  _3to4.b64_3(0);
281 
282  // chek for EOF
283  if(++_First == _Last)
284  {
285  // Error! Unexpected EOF. Must be '='. Ignore it.
286  //_St |= _IOS_BADBIT|_IOS_EOFBIT;
287  _St |= _IOS_EOFBIT;
288  }
289  else
290  if(_getCharType(*_First) != _EQUAL_CHAR)
291  {
292  // Error! Must be '='. Ignore it.
293  //_St |= _IOS_BADBIT;
294  }
295  else
296  ++_First; // Skip '='
297 
298  // write 1 byte to output
299  *_To = (byte_t) _3to4.get_0();
300  return _First;
301  }
302  else
303  _3to4.b64_2(_Char);
304 
305 
306  // -- 3 --
307  // Search next valid char...
308  while(++_First != _Last)
309  if((_Char = _getCharType(*_First)) != _UNKNOWN_CHAR)
310  break;
311 
312  if(_First == _Last) {
313  // Unexpected EOF. It's error. But ignore it.
314  //_St |= _IOS_FAILBIT|_IOS_EOFBIT;
315  _St |= _IOS_EOFBIT;
316 
317  return _First;
318  }
319 
320  if(_Char == _EQUAL_CHAR)
321  {
322  // OK!
323  _3to4.b64_3(0);
324 
325  // write to output 2 bytes
326  *_To = (byte_t) _3to4.get_0();
327  *_To = (byte_t) _3to4.get_1();
328 
329  ++_First; // set position to next character
330 
331  return _First;
332  }
333  else
334  _3to4.b64_3(_Char);
335 
336 
337  // write to output 3 bytes
338  *_To = (byte_t) _3to4.get_0();
339  *_To = (byte_t) _3to4.get_1();
340  *_To = (byte_t) _3to4.get_2();
341 
342  ++_First;
343 
344 
345  } // while(_First != _Last)
346 
347  return (_First);
348  }
349 
350 protected:
351 
352  int _getCharType(int _Ch) const
353  {
354  if(_base64Chars[62] == _Ch)
355  return 62;
356 
357  if(_base64Chars[63] == _Ch)
358  return 63;
359 
360  if((_base64Chars[0] <= _Ch) && (_base64Chars[25] >= _Ch))
361  return _Ch - _base64Chars[0];
362 
363  if((_base64Chars[26] <= _Ch) && (_base64Chars[51] >= _Ch))
364  return _Ch - _base64Chars[26] + 26;
365 
366  if((_base64Chars[52] <= _Ch) && (_base64Chars[61] >= _Ch))
367  return _Ch - _base64Chars[52] + 52;
368 
369  if(_Ch == _Tr::to_int_type('='))
370  return _EQUAL_CHAR;
371 
372  return _UNKNOWN_CHAR;
373  }
374 
375 
376 };
377 
378 
379 #endif