cpp/src/Ice/Base64.cpp

   1 // **********************************************************************
   2 //
   3 // Copyright (c) 2003-2011 ZeroC, Inc. All rights reserved.
   4 //
   5 // This copy of Ice is licensed to you under the terms described in the
   6 // ICE_LICENSE file included in this distribution.
   7 //
   8 // **********************************************************************
   9
  10 #include <Ice/Base64.h>
  11 #include <iterator>
  12
  13 using namespace std;
  14
  15 string
  16 IceInternal::Base64::encode(const vector<unsigned char>& plainSeq)
  17 {
  18     string retval;
  19
  20     if(plainSeq.size() == 0)
  21     {
  22         return retval;
  23     }
  24
  25     // Reserve enough space for the returned base64 string
  26     size_t base64Bytes = (((plainSeq.size() * 4) / 3) + 1);
  27     size_t newlineBytes = (((base64Bytes * 2) / 76) + 1);
  28     size_t totalBytes = base64Bytes + newlineBytes;
  29
  30     retval.reserve(totalBytes);
  31
  32     unsigned char by1 = 0;
  33     unsigned char by2 = 0;
  34     unsigned char by3 = 0;
  35     unsigned char by4 = 0;
  36     unsigned char by5 = 0;
  37     unsigned char by6 = 0;
  38     unsigned char by7 = 0;
  39
  40     for(size_t i = 0; i < plainSeq.size(); i += 3)
  41     {
  42         by1 = plainSeq[i];
  43         by2 = 0;
  44         by3 = 0;
  45
  46         if((i + 1) < plainSeq.size())
  47         {
  48             by2 = plainSeq[i+1];
  49         }
  50
  51         if((i + 2) < plainSeq.size())
  52         {
  53             by3 = plainSeq[i+2];
  54         }
  55
  56         by4 = by1 >> 2;
  57         by5 = ((by1 & 0x3) << 4) | (by2 >> 4);
  58         by6 = ((by2 & 0xf) << 2) | (by3 >> 6);
  59         by7 = by3 & 0x3f;
  60
  61         retval += encode(by4);
  62         retval += encode(by5);
  63
  64         if((i + 1) < plainSeq.size())
  65         {
  66             retval += encode(by6);
  67         }
  68         else
  69         {
  70             retval += "=";
  71         }
  72
  73         if((i + 2) < plainSeq.size())
  74         {
  75             retval += encode(by7);
  76         }
  77         else
  78         {
  79             retval += "=";
  80         }
  81     }
  82
  83     string outString;
  84     outString.reserve(totalBytes);
  85     string::iterator iter = retval.begin();
  86
  87     while((retval.end() - iter) > 76)
  88     {
  89         copy(iter, iter+76, back_inserter(outString));
  90         outString += "\r\n";
  91         iter += 76;
  92     }
  93
  94     copy(iter, retval.end(), back_inserter(outString));
  95
  96     return outString;
  97 }
  98
  99 vector<unsigned char>
 100 IceInternal::Base64::decode(const string& str)
 101 {
 102     string newStr;
 103
 104     newStr.reserve(str.length());
 105
 106     for(size_t j = 0; j < str.length(); j++)
 107     {
 108         if(isBase64(str[j]))
 109         {
 110             newStr += str[j];
 111         }
 112     }
 113
 114     vector<unsigned char> retval;
 115
 116     if(newStr.length() == 0)
 117     {
 118         return retval;
 119     }
 120
 121     // Note: This is how we were previously computing the size of the return
 122     //       sequence.  The method below is more efficient (and correct).
 123     // size_t lines = str.size() / 78;
 124     // size_t totalBytes = (lines * 76) + (((str.size() - (lines * 78)) * 3) / 4);
 125
 126     // Figure out how long the final sequence is going to be.
 127     size_t totalBytes = (newStr.size() * 3 / 4) + 1;
 128
 129     retval.reserve(totalBytes);
 130
 131     unsigned char by1 = 0;
 132     unsigned char by2 = 0;
 133     unsigned char by3 = 0;
 134     unsigned char by4 = 0;
 135
 136     char c1, c2, c3, c4;
 137
 138     for(size_t i = 0; i < newStr.length(); i += 4)
 139     {
 140         c1 = 'A';
 141         c2 = 'A';
 142         c3 = 'A';
 143         c4 = 'A';
 144
 145         c1 = newStr[i];
 146
 147         if((i + 1) < newStr.length())
 148         {
 149             c2 = newStr[i + 1];
 150         }
 151
 152         if((i + 2) < newStr.length())
 153         {
 154             c3 = newStr[i + 2];
 155         }
 156
 157         if((i + 3) < newStr.length())
 158         {
 159             c4 = newStr[i + 3];
 160         }
 161
 162         by1 = decode(c1);
 163         by2 = decode(c2);
 164         by3 = decode(c3);
 165         by4 = decode(c4);
 166
 167         retval.push_back((by1 << 2) | (by2 >> 4));
 168
 169         if(c3 != '=')
 170         {
 171             retval.push_back(((by2 & 0xf) << 4) | (by3 >> 2));
 172         }
 173
 174         if(c4 != '=')
 175         {
 176             retval.push_back(((by3 & 0x3) << 6) | by4);
 177         }
 178     }
 179
 180     return retval;
 181 }
 182
 183 bool
 184 IceInternal::Base64::isBase64(char c)
 185 {
 186     if(c >= 'A' && c <= 'Z')
 187     {
 188         return true;
 189     }
 190
 191     if(c >= 'a' && c <= 'z')
 192     {
 193         return true;
 194     }
 195
 196     if(c >= '0' && c <= '9')
 197     {
 198         return true;
 199     }
 200
 201     if(c == '+')
 202     {
 203         return true;
 204     }
 205
 206     if(c == '/')
 207     {
 208         return true;
 209     }
 210
 211     if(c == '=')
 212     {
 213         return true;
 214     }
 215
 216     return false;
 217 }
 218
 219 char
 220 IceInternal::Base64::encode(unsigned char uc)
 221 {
 222     if(uc < 26)
 223     {
 224         return 'A' + uc;
 225     }
 226
 227     if(uc < 52)
 228     {
 229         return 'a' + (uc - 26);
 230     }
 231
 232     if(uc < 62)
 233     {
 234         return '0' + (uc - 52);
 235     }
 236
 237     if(uc == 62)
 238     {
 239         return '+';
 240     }
 241
 242     return '/';
 243 }
 244
 245 unsigned char
 246 IceInternal::Base64::decode(char c)
 247 {
 248     if(c >= 'A' && c <= 'Z')
 249     {
 250         return c - 'A';
 251     }
 252
 253     if(c >= 'a' && c <= 'z')
 254     {
 255         return c - 'a' + 26;
 256     }
 257
 258     if(c >= '0' && c <= '9')
 259     {
 260         return c - '0' + 52;
 261     }
 262
 263     if(c == '+')
 264     {
 265         return 62;
 266     }
 267
 268     return 63;
 269 }