diff options
Diffstat (limited to 'chromium/third_party/webrtc/base/base64.cc')
| -rw-r--r-- | chromium/third_party/webrtc/base/base64.cc | 260 |
1 files changed, 260 insertions, 0 deletions
diff --git a/chromium/third_party/webrtc/base/base64.cc b/chromium/third_party/webrtc/base/base64.cc new file mode 100644 index 00000000000..7ed373e8965 --- /dev/null +++ b/chromium/third_party/webrtc/base/base64.cc @@ -0,0 +1,260 @@ + +//********************************************************************* +//* Base64 - a simple base64 encoder and decoder. +//* +//* Copyright (c) 1999, Bob Withers - bwit@pobox.com +//* +//* This code may be freely used for any purpose, either personal +//* or commercial, provided the authors copyright notice remains +//* intact. +//* +//* Enhancements by Stanley Yamane: +//* o reverse lookup table for the decode function +//* o reserve string buffer space in advance +//* +//********************************************************************* + +#include "webrtc/base/base64.h" + +#include <string.h> + +#include "webrtc/base/common.h" + +using std::vector; + +namespace rtc { + +static const char kPad = '='; +static const unsigned char pd = 0xFD; // Padding +static const unsigned char sp = 0xFE; // Whitespace +static const unsigned char il = 0xFF; // Illegal base64 character + +const char Base64::Base64Table[] = +// 0000000000111111111122222222223333333333444444444455555555556666 +// 0123456789012345678901234567890123456789012345678901234567890123 + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; + +// Decode Table gives the index of any valid base64 character in the +// Base64 table +// 65 == A, 97 == a, 48 == 0, 43 == +, 47 == / + +const unsigned char Base64::DecodeTable[] = { +// 0 1 2 3 4 5 6 7 8 9 + il,il,il,il,il,il,il,il,il,sp, // 0 - 9 + sp,sp,sp,sp,il,il,il,il,il,il, // 10 - 19 + il,il,il,il,il,il,il,il,il,il, // 20 - 29 + il,il,sp,il,il,il,il,il,il,il, // 30 - 39 + il,il,il,62,il,il,il,63,52,53, // 40 - 49 + 54,55,56,57,58,59,60,61,il,il, // 50 - 59 + il,pd,il,il,il, 0, 1, 2, 3, 4, // 60 - 69 + 5, 6, 7, 8, 9,10,11,12,13,14, // 70 - 79 + 15,16,17,18,19,20,21,22,23,24, // 80 - 89 + 25,il,il,il,il,il,il,26,27,28, // 90 - 99 + 29,30,31,32,33,34,35,36,37,38, // 100 - 109 + 39,40,41,42,43,44,45,46,47,48, // 110 - 119 + 49,50,51,il,il,il,il,il,il,il, // 120 - 129 + il,il,il,il,il,il,il,il,il,il, // 130 - 139 + il,il,il,il,il,il,il,il,il,il, // 140 - 149 + il,il,il,il,il,il,il,il,il,il, // 150 - 159 + il,il,il,il,il,il,il,il,il,il, // 160 - 169 + il,il,il,il,il,il,il,il,il,il, // 170 - 179 + il,il,il,il,il,il,il,il,il,il, // 180 - 189 + il,il,il,il,il,il,il,il,il,il, // 190 - 199 + il,il,il,il,il,il,il,il,il,il, // 200 - 209 + il,il,il,il,il,il,il,il,il,il, // 210 - 219 + il,il,il,il,il,il,il,il,il,il, // 220 - 229 + il,il,il,il,il,il,il,il,il,il, // 230 - 239 + il,il,il,il,il,il,il,il,il,il, // 240 - 249 + il,il,il,il,il,il // 250 - 255 +}; + +bool Base64::IsBase64Char(char ch) { + return (('A' <= ch) && (ch <= 'Z')) || + (('a' <= ch) && (ch <= 'z')) || + (('0' <= ch) && (ch <= '9')) || + (ch == '+') || (ch == '/'); +} + +bool Base64::GetNextBase64Char(char ch, char* next_ch) { + if (next_ch == NULL) { + return false; + } + const char* p = strchr(Base64Table, ch); + if (!p) + return false; + ++p; + *next_ch = (*p) ? *p : Base64Table[0]; + return true; +} + +bool Base64::IsBase64Encoded(const std::string& str) { + for (size_t i = 0; i < str.size(); ++i) { + if (!IsBase64Char(str.at(i))) + return false; + } + return true; +} + +void Base64::EncodeFromArray(const void* data, size_t len, + std::string* result) { + ASSERT(NULL != result); + result->clear(); + result->resize(((len + 2) / 3) * 4); + const unsigned char* byte_data = static_cast<const unsigned char*>(data); + + unsigned char c; + size_t i = 0; + size_t dest_ix = 0; + while (i < len) { + c = (byte_data[i] >> 2) & 0x3f; + (*result)[dest_ix++] = Base64Table[c]; + + c = (byte_data[i] << 4) & 0x3f; + if (++i < len) { + c |= (byte_data[i] >> 4) & 0x0f; + } + (*result)[dest_ix++] = Base64Table[c]; + + if (i < len) { + c = (byte_data[i] << 2) & 0x3f; + if (++i < len) { + c |= (byte_data[i] >> 6) & 0x03; + } + (*result)[dest_ix++] = Base64Table[c]; + } else { + (*result)[dest_ix++] = kPad; + } + + if (i < len) { + c = byte_data[i] & 0x3f; + (*result)[dest_ix++] = Base64Table[c]; + ++i; + } else { + (*result)[dest_ix++] = kPad; + } + } +} + +size_t Base64::GetNextQuantum(DecodeFlags parse_flags, bool illegal_pads, + const char* data, size_t len, size_t* dpos, + unsigned char qbuf[4], bool* padded) +{ + size_t byte_len = 0, pad_len = 0, pad_start = 0; + for (; (byte_len < 4) && (*dpos < len); ++*dpos) { + qbuf[byte_len] = DecodeTable[static_cast<unsigned char>(data[*dpos])]; + if ((il == qbuf[byte_len]) || (illegal_pads && (pd == qbuf[byte_len]))) { + if (parse_flags != DO_PARSE_ANY) + break; + // Ignore illegal characters + } else if (sp == qbuf[byte_len]) { + if (parse_flags == DO_PARSE_STRICT) + break; + // Ignore spaces + } else if (pd == qbuf[byte_len]) { + if (byte_len < 2) { + if (parse_flags != DO_PARSE_ANY) + break; + // Ignore unexpected padding + } else if (byte_len + pad_len >= 4) { + if (parse_flags != DO_PARSE_ANY) + break; + // Ignore extra pads + } else { + if (1 == ++pad_len) { + pad_start = *dpos; + } + } + } else { + if (pad_len > 0) { + if (parse_flags != DO_PARSE_ANY) + break; + // Ignore pads which are followed by data + pad_len = 0; + } + ++byte_len; + } + } + for (size_t i = byte_len; i < 4; ++i) { + qbuf[i] = 0; + } + if (4 == byte_len + pad_len) { + *padded = true; + } else { + *padded = false; + if (pad_len) { + // Roll back illegal padding + *dpos = pad_start; + } + } + return byte_len; +} + +bool Base64::DecodeFromArray(const char* data, size_t len, DecodeFlags flags, + std::string* result, size_t* data_used) { + return DecodeFromArrayTemplate<std::string>( + data, len, flags, result, data_used); +} + +bool Base64::DecodeFromArray(const char* data, size_t len, DecodeFlags flags, + vector<char>* result, size_t* data_used) { + return DecodeFromArrayTemplate<vector<char> >(data, len, flags, result, + data_used); +} + +template<typename T> +bool Base64::DecodeFromArrayTemplate(const char* data, size_t len, + DecodeFlags flags, T* result, + size_t* data_used) +{ + ASSERT(NULL != result); + ASSERT(flags <= (DO_PARSE_MASK | DO_PAD_MASK | DO_TERM_MASK)); + + const DecodeFlags parse_flags = flags & DO_PARSE_MASK; + const DecodeFlags pad_flags = flags & DO_PAD_MASK; + const DecodeFlags term_flags = flags & DO_TERM_MASK; + ASSERT(0 != parse_flags); + ASSERT(0 != pad_flags); + ASSERT(0 != term_flags); + + result->clear(); + result->reserve(len); + + size_t dpos = 0; + bool success = true, padded; + unsigned char c, qbuf[4]; + while (dpos < len) { + size_t qlen = GetNextQuantum(parse_flags, (DO_PAD_NO == pad_flags), + data, len, &dpos, qbuf, &padded); + c = (qbuf[0] << 2) | ((qbuf[1] >> 4) & 0x3); + if (qlen >= 2) { + result->push_back(c); + c = ((qbuf[1] << 4) & 0xf0) | ((qbuf[2] >> 2) & 0xf); + if (qlen >= 3) { + result->push_back(c); + c = ((qbuf[2] << 6) & 0xc0) | qbuf[3]; + if (qlen >= 4) { + result->push_back(c); + c = 0; + } + } + } + if (qlen < 4) { + if ((DO_TERM_ANY != term_flags) && (0 != c)) { + success = false; // unused bits + } + if ((DO_PAD_YES == pad_flags) && !padded) { + success = false; // expected padding + } + break; + } + } + if ((DO_TERM_BUFFER == term_flags) && (dpos != len)) { + success = false; // unused chars + } + if (data_used) { + *data_used = dpos; + } + return success; +} + +} // namespace rtc |