include/ocCoder.h

Go to the documentation of this file.

#ifndef OC_CODER_H
#define OC_CODER_H

#include <string>
#include <algorithm>
#include <vector>


using namespace std;

// since max line for mail transport=76, use 4/3(76), or 57, for bin encode length
const size_t  ENCODELength = 57;
const size_t  DECODELength = 76;
const size_t  REVARRAYSize = 126;

// pack the structure byte tight
#pragma pack(1)
#ifdef IS_BIG_ENDIAN
union b24bits
{
  struct {
    unsigned int ch4:6;
    unsigned int ch3:6;
    unsigned int ch2:6;
    unsigned int ch1:6;
  } bit6Sequence;
  struct {
    unsigned char ch3;
    unsigned char ch2;
    unsigned char ch1;
  } byteSequence;
};
#else
union b24bits
{
  struct {
    unsigned int ch1:6;
    unsigned int ch2:6;
    unsigned int ch3:6;
    unsigned int ch4:6;
  } bit6Sequence;
  struct {
    unsigned char ch1;
    unsigned char ch2;
    unsigned char ch3;
  } byteSequence;
};
#endif
// return to normal stucture (probably machine word size) boundaries
#pragma pack()

typedef vector< unsigned char > bins;

class ocCoder
{
private:
  string  alphabet;
  bins    ralphabet;
  bins    bindata;
  string  base64data;
  char    base64pad;
  b24bits base64mask;

public:
  ocCoder()
  // The forward map for encoding
          //           1         2         3         4         5         6
          // 0123456789012345678901234567890123456789012345678901234567890123
  :alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/")
  ,ralphabet(REVARRAYSize,'\0')
  ,bindata(ENCODELength,'\0')
  ,base64pad('=')
  {
    // the reverse map for decoding;
    ralphabet[65] = 0;    ralphabet[66] = 1;    ralphabet[67] = 2;    ralphabet[68] = 3;
    ralphabet[69] = 4;    ralphabet[70] = 5;    ralphabet[71] = 6;    ralphabet[72] = 7;
    ralphabet[73] = 8;    ralphabet[74] = 9;    ralphabet[75] = 10;    ralphabet[76] = 11;
    ralphabet[77] = 12;    ralphabet[78] = 13;    ralphabet[79] = 14;    ralphabet[80] = 15;
    ralphabet[81] = 16;    ralphabet[82] = 17;    ralphabet[83] = 18;    ralphabet[84] = 19;
    ralphabet[85] = 20;    ralphabet[86] = 21;    ralphabet[87] = 22;    ralphabet[88] = 23;
    ralphabet[89] = 24;    ralphabet[90] = 25;    ralphabet[97] = 26;    ralphabet[98] = 27;
    ralphabet[99] = 28;    ralphabet[100] = 29;    ralphabet[101] = 30;    ralphabet[102] = 31;
    ralphabet[103] = 32;    ralphabet[104] = 33;    ralphabet[105] = 34;    ralphabet[106] = 35;
    ralphabet[107] = 36;    ralphabet[108] = 37;    ralphabet[109] = 38;    ralphabet[110] = 39;
    ralphabet[111] = 40;    ralphabet[112] = 41;    ralphabet[113] = 42;    ralphabet[114] = 43;
    ralphabet[115] = 44;    ralphabet[116] = 45;    ralphabet[117] = 46;    ralphabet[118] = 47;
    ralphabet[119] = 48;    ralphabet[120] = 49;    ralphabet[121] = 50;    ralphabet[122] = 51;
    ralphabet[48] = 52;    ralphabet[49] = 53;    ralphabet[50] = 54;    ralphabet[51] = 55;
    ralphabet[52] = 56;    ralphabet[53] = 57;    ralphabet[54] = 58;    ralphabet[55] = 59;
    ralphabet[56] = 60;    ralphabet[57] = 61;    ralphabet[43] = 62;    ralphabet[47] = 63;
  }

  virtual ~ocCoder()
  {;}

  /*
    Take binary segment of length and convert in to base64
  */
  string & base64encode( const unsigned char * input, size_t length )
  {
    // initialize the output data
    base64data = "";
    base64data.resize(DECODELength);

    // The function won't do much if the length is to big
    if( length <= ENCODELength )
    {
      int idx,odx;
      for( idx=0,odx=0;
          input && idx < length;
          idx += 3, odx+=4 )
      {
        // clear the union
        memset( &base64mask, 0, 3 );

        // Put the three raw values in the union
        base64mask.byteSequence.ch3 = input[idx];
        if( (idx+1) < length ) base64mask.byteSequence.ch2 = input[idx+1];
        if( (idx+2) < length ) base64mask.byteSequence.ch1 = input[idx+2];

        // Translate the four output values and put them into the return string
        base64data[odx]   = alphabet[base64mask.bit6Sequence.ch4];
        base64data[odx+1] = alphabet[base64mask.bit6Sequence.ch3];
        // See about padding
        if( (idx+1) < length ) base64data[odx+2] = alphabet[base64mask.bit6Sequence.ch2];
        else base64data[odx+2] = base64pad;
        if( (idx+2) < length ) base64data[odx+3] = alphabet[base64mask.bit6Sequence.ch1];
        else base64data[odx+3] = base64pad;
      }
    }
    return base64data;
  }

  bins & base64decode ( string & encoded )
  {
    bindata.clear();
    int idx;
    // four chars at a time
    for( idx = 0; idx < encoded.length(); idx+=4 )
    {
      // clear the union
      memset( &base64mask, 0, 3 );

      // Put 4 elements into the union
      base64mask.bit6Sequence.ch4 = ralphabet[encoded[idx]];
      base64mask.bit6Sequence.ch3 = ralphabet[encoded[idx+1]];
      if(encoded[idx+2] != base64pad) base64mask.bit6Sequence.ch2 = ralphabet[encoded[idx+2]];
      if(encoded[idx+3] != base64pad) base64mask.bit6Sequence.ch1 = ralphabet[encoded[idx+3]];

      // Take binary data out of the union and put into the vector
      bindata.push_back(base64mask.byteSequence.ch3);
      if(encoded[idx+2] != base64pad) bindata.push_back(base64mask.byteSequence.ch2);
      if(encoded[idx+3] != base64pad) bindata.push_back(base64mask.byteSequence.ch1);
    }

    // Return the output
    return bindata;
  }

  string & data( void )
  {
    return base64data;
  }
};

// define a stream operator for bins
ostream & operator << ( ostream & outstream, bins & binary )
{
  for( int i=0; i < binary.size(); i++ )
  {
    outstream.put( binary[i] );
  }
  return outstream;
}

#endif

---