henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 1 | |
| 2 | //********************************************************************* |
| 3 | //* Base64 - a simple base64 encoder and decoder. |
| 4 | //* |
| 5 | //* Copyright (c) 1999, Bob Withers - bwit@pobox.com |
| 6 | //* |
| 7 | //* This code may be freely used for any purpose, either personal |
| 8 | //* or commercial, provided the authors copyright notice remains |
| 9 | //* intact. |
| 10 | //* |
| 11 | //* Enhancements by Stanley Yamane: |
| 12 | //* o reverse lookup table for the decode function |
| 13 | //* o reserve string buffer space in advance |
| 14 | //* |
| 15 | //********************************************************************* |
| 16 | |
| 17 | #include "talk/base/base64.h" |
| 18 | |
| 19 | #include <string.h> |
| 20 | |
| 21 | #include "talk/base/common.h" |
| 22 | |
henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 23 | using std::vector; |
| 24 | |
| 25 | namespace talk_base { |
| 26 | |
| 27 | static const char kPad = '='; |
| 28 | static const unsigned char pd = 0xFD; // Padding |
| 29 | static const unsigned char sp = 0xFE; // Whitespace |
| 30 | static const unsigned char il = 0xFF; // Illegal base64 character |
| 31 | |
| 32 | const char Base64::Base64Table[] = |
| 33 | // 0000000000111111111122222222223333333333444444444455555555556666 |
| 34 | // 0123456789012345678901234567890123456789012345678901234567890123 |
| 35 | "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
| 36 | |
| 37 | // Decode Table gives the index of any valid base64 character in the |
| 38 | // Base64 table |
| 39 | // 65 == A, 97 == a, 48 == 0, 43 == +, 47 == / |
| 40 | |
| 41 | const unsigned char Base64::DecodeTable[] = { |
| 42 | // 0 1 2 3 4 5 6 7 8 9 |
| 43 | il,il,il,il,il,il,il,il,il,sp, // 0 - 9 |
| 44 | sp,sp,sp,sp,il,il,il,il,il,il, // 10 - 19 |
| 45 | il,il,il,il,il,il,il,il,il,il, // 20 - 29 |
| 46 | il,il,sp,il,il,il,il,il,il,il, // 30 - 39 |
| 47 | il,il,il,62,il,il,il,63,52,53, // 40 - 49 |
| 48 | 54,55,56,57,58,59,60,61,il,il, // 50 - 59 |
| 49 | il,pd,il,il,il, 0, 1, 2, 3, 4, // 60 - 69 |
| 50 | 5, 6, 7, 8, 9,10,11,12,13,14, // 70 - 79 |
| 51 | 15,16,17,18,19,20,21,22,23,24, // 80 - 89 |
| 52 | 25,il,il,il,il,il,il,26,27,28, // 90 - 99 |
| 53 | 29,30,31,32,33,34,35,36,37,38, // 100 - 109 |
| 54 | 39,40,41,42,43,44,45,46,47,48, // 110 - 119 |
| 55 | 49,50,51,il,il,il,il,il,il,il, // 120 - 129 |
| 56 | il,il,il,il,il,il,il,il,il,il, // 130 - 139 |
| 57 | il,il,il,il,il,il,il,il,il,il, // 140 - 149 |
| 58 | il,il,il,il,il,il,il,il,il,il, // 150 - 159 |
| 59 | il,il,il,il,il,il,il,il,il,il, // 160 - 169 |
| 60 | il,il,il,il,il,il,il,il,il,il, // 170 - 179 |
| 61 | il,il,il,il,il,il,il,il,il,il, // 180 - 189 |
| 62 | il,il,il,il,il,il,il,il,il,il, // 190 - 199 |
| 63 | il,il,il,il,il,il,il,il,il,il, // 200 - 209 |
| 64 | il,il,il,il,il,il,il,il,il,il, // 210 - 219 |
| 65 | il,il,il,il,il,il,il,il,il,il, // 220 - 229 |
| 66 | il,il,il,il,il,il,il,il,il,il, // 230 - 239 |
| 67 | il,il,il,il,il,il,il,il,il,il, // 240 - 249 |
| 68 | il,il,il,il,il,il // 250 - 255 |
| 69 | }; |
| 70 | |
| 71 | bool Base64::IsBase64Char(char ch) { |
| 72 | return (('A' <= ch) && (ch <= 'Z')) || |
| 73 | (('a' <= ch) && (ch <= 'z')) || |
| 74 | (('0' <= ch) && (ch <= '9')) || |
| 75 | (ch == '+') || (ch == '/'); |
| 76 | } |
| 77 | |
| 78 | bool Base64::GetNextBase64Char(char ch, char* next_ch) { |
| 79 | if (next_ch == NULL) { |
| 80 | return false; |
| 81 | } |
| 82 | const char* p = strchr(Base64Table, ch); |
| 83 | if (!p) |
| 84 | return false; |
| 85 | ++p; |
| 86 | *next_ch = (*p) ? *p : Base64Table[0]; |
| 87 | return true; |
| 88 | } |
| 89 | |
| 90 | bool Base64::IsBase64Encoded(const std::string& str) { |
| 91 | for (size_t i = 0; i < str.size(); ++i) { |
| 92 | if (!IsBase64Char(str.at(i))) |
| 93 | return false; |
| 94 | } |
| 95 | return true; |
| 96 | } |
| 97 | |
wu@webrtc.org | d1f631d | 2013-10-30 05:18:12 +0000 | [diff] [blame] | 98 | void Base64::EncodeFromArray(const void* data, size_t len, |
| 99 | std::string* result) { |
henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 100 | ASSERT(NULL != result); |
| 101 | result->clear(); |
| 102 | result->resize(((len + 2) / 3) * 4); |
| 103 | const unsigned char* byte_data = static_cast<const unsigned char*>(data); |
| 104 | |
| 105 | unsigned char c; |
| 106 | size_t i = 0; |
| 107 | size_t dest_ix = 0; |
| 108 | while (i < len) { |
| 109 | c = (byte_data[i] >> 2) & 0x3f; |
| 110 | (*result)[dest_ix++] = Base64Table[c]; |
| 111 | |
| 112 | c = (byte_data[i] << 4) & 0x3f; |
| 113 | if (++i < len) { |
| 114 | c |= (byte_data[i] >> 4) & 0x0f; |
| 115 | } |
| 116 | (*result)[dest_ix++] = Base64Table[c]; |
| 117 | |
| 118 | if (i < len) { |
| 119 | c = (byte_data[i] << 2) & 0x3f; |
| 120 | if (++i < len) { |
| 121 | c |= (byte_data[i] >> 6) & 0x03; |
| 122 | } |
| 123 | (*result)[dest_ix++] = Base64Table[c]; |
| 124 | } else { |
| 125 | (*result)[dest_ix++] = kPad; |
| 126 | } |
| 127 | |
| 128 | if (i < len) { |
| 129 | c = byte_data[i] & 0x3f; |
| 130 | (*result)[dest_ix++] = Base64Table[c]; |
| 131 | ++i; |
| 132 | } else { |
| 133 | (*result)[dest_ix++] = kPad; |
| 134 | } |
| 135 | } |
| 136 | } |
| 137 | |
| 138 | size_t Base64::GetNextQuantum(DecodeFlags parse_flags, bool illegal_pads, |
| 139 | const char* data, size_t len, size_t* dpos, |
| 140 | unsigned char qbuf[4], bool* padded) |
| 141 | { |
| 142 | size_t byte_len = 0, pad_len = 0, pad_start = 0; |
| 143 | for (; (byte_len < 4) && (*dpos < len); ++*dpos) { |
| 144 | qbuf[byte_len] = DecodeTable[static_cast<unsigned char>(data[*dpos])]; |
| 145 | if ((il == qbuf[byte_len]) || (illegal_pads && (pd == qbuf[byte_len]))) { |
| 146 | if (parse_flags != DO_PARSE_ANY) |
| 147 | break; |
| 148 | // Ignore illegal characters |
| 149 | } else if (sp == qbuf[byte_len]) { |
| 150 | if (parse_flags == DO_PARSE_STRICT) |
| 151 | break; |
| 152 | // Ignore spaces |
| 153 | } else if (pd == qbuf[byte_len]) { |
| 154 | if (byte_len < 2) { |
| 155 | if (parse_flags != DO_PARSE_ANY) |
| 156 | break; |
| 157 | // Ignore unexpected padding |
| 158 | } else if (byte_len + pad_len >= 4) { |
| 159 | if (parse_flags != DO_PARSE_ANY) |
| 160 | break; |
| 161 | // Ignore extra pads |
| 162 | } else { |
| 163 | if (1 == ++pad_len) { |
| 164 | pad_start = *dpos; |
| 165 | } |
| 166 | } |
| 167 | } else { |
| 168 | if (pad_len > 0) { |
| 169 | if (parse_flags != DO_PARSE_ANY) |
| 170 | break; |
| 171 | // Ignore pads which are followed by data |
| 172 | pad_len = 0; |
| 173 | } |
| 174 | ++byte_len; |
| 175 | } |
| 176 | } |
| 177 | for (size_t i = byte_len; i < 4; ++i) { |
| 178 | qbuf[i] = 0; |
| 179 | } |
| 180 | if (4 == byte_len + pad_len) { |
| 181 | *padded = true; |
| 182 | } else { |
| 183 | *padded = false; |
| 184 | if (pad_len) { |
| 185 | // Roll back illegal padding |
| 186 | *dpos = pad_start; |
| 187 | } |
| 188 | } |
| 189 | return byte_len; |
| 190 | } |
| 191 | |
| 192 | bool Base64::DecodeFromArray(const char* data, size_t len, DecodeFlags flags, |
wu@webrtc.org | d1f631d | 2013-10-30 05:18:12 +0000 | [diff] [blame] | 193 | std::string* result, size_t* data_used) { |
| 194 | return DecodeFromArrayTemplate<std::string>( |
| 195 | data, len, flags, result, data_used); |
henrike@webrtc.org | 0e118e7 | 2013-07-10 00:45:36 +0000 | [diff] [blame] | 196 | } |
| 197 | |
| 198 | bool Base64::DecodeFromArray(const char* data, size_t len, DecodeFlags flags, |
| 199 | vector<char>* result, size_t* data_used) { |
| 200 | return DecodeFromArrayTemplate<vector<char> >(data, len, flags, result, |
| 201 | data_used); |
| 202 | } |
| 203 | |
| 204 | template<typename T> |
| 205 | bool Base64::DecodeFromArrayTemplate(const char* data, size_t len, |
| 206 | DecodeFlags flags, T* result, |
| 207 | size_t* data_used) |
| 208 | { |
| 209 | ASSERT(NULL != result); |
| 210 | ASSERT(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK)); |
| 211 | |
| 212 | const DecodeFlags parse_flags = flags & DO_PARSE_MASK; |
| 213 | const DecodeFlags pad_flags = flags & DO_PAD_MASK; |
| 214 | const DecodeFlags term_flags = flags & DO_TERM_MASK; |
| 215 | ASSERT(0 != parse_flags); |
| 216 | ASSERT(0 != pad_flags); |
| 217 | ASSERT(0 != term_flags); |
| 218 | |
| 219 | result->clear(); |
| 220 | result->reserve(len); |
| 221 | |
| 222 | size_t dpos = 0; |
| 223 | bool success = true, padded; |
| 224 | unsigned char c, qbuf[4]; |
| 225 | while (dpos < len) { |
| 226 | size_t qlen = GetNextQuantum(parse_flags, (DO_PAD_NO == pad_flags), |
| 227 | data, len, &dpos, qbuf, &padded); |
| 228 | c = (qbuf[0] << 2) | ((qbuf[1] >> 4) & 0x3); |
| 229 | if (qlen >= 2) { |
| 230 | result->push_back(c); |
| 231 | c = ((qbuf[1] << 4) & 0xf0) | ((qbuf[2] >> 2) & 0xf); |
| 232 | if (qlen >= 3) { |
| 233 | result->push_back(c); |
| 234 | c = ((qbuf[2] << 6) & 0xc0) | qbuf[3]; |
| 235 | if (qlen >= 4) { |
| 236 | result->push_back(c); |
| 237 | c = 0; |
| 238 | } |
| 239 | } |
| 240 | } |
| 241 | if (qlen < 4) { |
| 242 | if ((DO_TERM_ANY != term_flags) && (0 != c)) { |
| 243 | success = false; // unused bits |
| 244 | } |
| 245 | if ((DO_PAD_YES == pad_flags) && !padded) { |
| 246 | success = false; // expected padding |
| 247 | } |
| 248 | break; |
| 249 | } |
| 250 | } |
| 251 | if ((DO_TERM_BUFFER == term_flags) && (dpos != len)) { |
| 252 | success = false; // unused chars |
| 253 | } |
| 254 | if (data_used) { |
| 255 | *data_used = dpos; |
| 256 | } |
| 257 | return success; |
| 258 | } |
| 259 | |
| 260 | } // namespace talk_base |