| // Copyright 2019 Google LLC |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google LLC nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| #ifdef HAVE_CONFIG_H |
| #include <config.h> // Must come first |
| #endif |
| |
| #include "tools/windows/converter_exe/escaping.h" |
| |
| #include <assert.h> |
| |
| #define kApb kAsciiPropertyBits |
| |
| const unsigned char kAsciiPropertyBits[256] = { |
| 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x00 |
| 0x40, 0x68, 0x48, 0x48, 0x48, 0x48, 0x40, 0x40, |
| 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, // 0x10 |
| 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, 0x40, |
| 0x28, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, // 0x20 |
| 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, |
| 0x84, 0x84, 0x10, 0x10, 0x10, 0x10, 0x10, 0x10, |
| 0x10, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x05, // 0x40 |
| 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, |
| 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, // 0x50 |
| 0x05, 0x05, 0x05, 0x10, 0x10, 0x10, 0x10, 0x10, |
| 0x10, 0x85, 0x85, 0x85, 0x85, 0x85, 0x85, 0x05, // 0x60 |
| 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, |
| 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, // 0x70 |
| 0x05, 0x05, 0x05, 0x10, 0x10, 0x10, 0x10, 0x40, |
| }; |
| |
| // Use !! to suppress the warning C4800 of forcing 'int' to 'bool'. |
| static inline bool ascii_isspace(unsigned char c) { return !!(kApb[c] & 0x08); } |
| |
| /////////////////////////////////// |
| // scoped_array |
| /////////////////////////////////// |
| // scoped_array<C> is like scoped_ptr<C>, except that the caller must allocate |
| // with new [] and the destructor deletes objects with delete []. |
| // |
| // As with scoped_ptr<C>, a scoped_array<C> either points to an object |
| // or is NULL. A scoped_array<C> owns the object that it points to. |
| // scoped_array<T> is thread-compatible, and once you index into it, |
| // the returned objects have only the threadsafety guarantees of T. |
| // |
| // Size: sizeof(scoped_array<C>) == sizeof(C*) |
| template <class C> |
| class scoped_array { |
| public: |
| |
| // The element type |
| typedef C element_type; |
| |
| // Constructor. Defaults to intializing with NULL. |
| // There is no way to create an uninitialized scoped_array. |
| // The input parameter must be allocated with new []. |
| explicit scoped_array(C* p = NULL) : array_(p) { } |
| |
| // Destructor. If there is a C object, delete it. |
| // We don't need to test ptr_ == NULL because C++ does that for us. |
| ~scoped_array() { |
| enum { type_must_be_complete = sizeof(C) }; |
| delete[] array_; |
| } |
| |
| // Reset. Deletes the current owned object, if any. |
| // Then takes ownership of a new object, if given. |
| // this->reset(this->get()) works. |
| void reset(C* p = NULL) { |
| if (p != array_) { |
| enum { type_must_be_complete = sizeof(C) }; |
| delete[] array_; |
| array_ = p; |
| } |
| } |
| |
| // Get one element of the current object. |
| // Will assert() if there is no current object, or index i is negative. |
| C& operator[](std::ptrdiff_t i) const { |
| assert(i >= 0); |
| assert(array_ != NULL); |
| return array_[i]; |
| } |
| |
| // Get a pointer to the zeroth element of the current object. |
| // If there is no current object, return NULL. |
| C* get() const { |
| return array_; |
| } |
| |
| // Comparison operators. |
| // These return whether a scoped_array and a raw pointer refer to |
| // the same array, not just to two different but equal arrays. |
| bool operator==(const C* p) const { return array_ == p; } |
| bool operator!=(const C* p) const { return array_ != p; } |
| |
| // Swap two scoped arrays. |
| void swap(scoped_array& p2) { |
| C* tmp = array_; |
| array_ = p2.array_; |
| p2.array_ = tmp; |
| } |
| |
| // Release an array. |
| // The return value is the current pointer held by this object. |
| // If this object holds a NULL pointer, the return value is NULL. |
| // After this operation, this object will hold a NULL pointer, |
| // and will not own the object any more. |
| C* release() { |
| C* retVal = array_; |
| array_ = NULL; |
| return retVal; |
| } |
| |
| private: |
| C* array_; |
| |
| // Forbid comparison of different scoped_array types. |
| template <class C2> bool operator==(scoped_array<C2> const& p2) const; |
| template <class C2> bool operator!=(scoped_array<C2> const& p2) const; |
| |
| // Disallow evil constructors |
| scoped_array(const scoped_array&); |
| void operator=(const scoped_array&); |
| }; |
| |
| |
| /////////////////////////////////// |
| // Escape methods |
| /////////////////////////////////// |
| |
| namespace strings { |
| |
| // Return a mutable char* pointing to a string's internal buffer, |
| // which may not be null-terminated. Writing through this pointer will |
| // modify the string. |
| // |
| // string_as_array(&str)[i] is valid for 0 <= i < str.size() until the |
| // next call to a string method that invalidates iterators. |
| // |
| // As of 2006-04, there is no standard-blessed way of getting a |
| // mutable reference to a string's internal buffer. However, issue 530 |
| // (http://www.open-std.org/JTC1/SC22/WG21/docs/lwg-active.html#530) |
| // proposes this as the method. According to Matt Austern, this should |
| // already work on all current implementations. |
| inline char* string_as_array(string* str) { |
| // DO NOT USE const_cast<char*>(str->data())! See the unittest for why. |
| return str->empty() ? NULL : &*str->begin(); |
| } |
| |
| int CalculateBase64EscapedLen(int input_len, bool do_padding) { |
| // these formulae were copied from comments that used to go with the base64 |
| // encoding functions |
| int intermediate_result = 8 * input_len + 5; |
| assert(intermediate_result > 0); // make sure we didn't overflow |
| int len = intermediate_result / 6; |
| if (do_padding) len = ((len + 3) / 4) * 4; |
| return len; |
| } |
| |
| // Base64Escape does padding, so this calculation includes padding. |
| int CalculateBase64EscapedLen(int input_len) { |
| return CalculateBase64EscapedLen(input_len, true); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // int Base64Unescape() - base64 decoder |
| // int Base64Escape() - base64 encoder |
| // int WebSafeBase64Unescape() - Google's variation of base64 decoder |
| // int WebSafeBase64Escape() - Google's variation of base64 encoder |
| // |
| // Check out |
| // http://www.cis.ohio-state.edu/htbin/rfc/rfc2045.html for formal |
| // description, but what we care about is that... |
| // Take the encoded stuff in groups of 4 characters and turn each |
| // character into a code 0 to 63 thus: |
| // A-Z map to 0 to 25 |
| // a-z map to 26 to 51 |
| // 0-9 map to 52 to 61 |
| // +(- for WebSafe) maps to 62 |
| // /(_ for WebSafe) maps to 63 |
| // There will be four numbers, all less than 64 which can be represented |
| // by a 6 digit binary number (aaaaaa, bbbbbb, cccccc, dddddd respectively). |
| // Arrange the 6 digit binary numbers into three bytes as such: |
| // aaaaaabb bbbbcccc ccdddddd |
| // Equals signs (one or two) are used at the end of the encoded block to |
| // indicate that the text was not an integer multiple of three bytes long. |
| // ---------------------------------------------------------------------- |
| |
| int Base64UnescapeInternal(const char *src, int szsrc, |
| char *dest, int szdest, |
| const signed char* unbase64) { |
| static const char kPad64 = '='; |
| |
| int decode = 0; |
| int destidx = 0; |
| int state = 0; |
| unsigned int ch = 0; |
| unsigned int temp = 0; |
| |
| // The GET_INPUT macro gets the next input character, skipping |
| // over any whitespace, and stopping when we reach the end of the |
| // string or when we read any non-data character. The arguments are |
| // an arbitrary identifier (used as a label for goto) and the number |
| // of data bytes that must remain in the input to avoid aborting the |
| // loop. |
| #define GET_INPUT(label, remain) \ |
| label: \ |
| --szsrc; \ |
| ch = *src++; \ |
| decode = unbase64[ch]; \ |
| if (decode < 0) { \ |
| if (ascii_isspace((char)ch) && szsrc >= remain) \ |
| goto label; \ |
| state = 4 - remain; \ |
| break; \ |
| } |
| |
| // if dest is null, we're just checking to see if it's legal input |
| // rather than producing output. (I suspect this could just be done |
| // with a regexp...). We duplicate the loop so this test can be |
| // outside it instead of in every iteration. |
| |
| if (dest) { |
| // This loop consumes 4 input bytes and produces 3 output bytes |
| // per iteration. We can't know at the start that there is enough |
| // data left in the string for a full iteration, so the loop may |
| // break out in the middle; if so 'state' will be set to the |
| // number of input bytes read. |
| |
| while (szsrc >= 4) { |
| // We'll start by optimistically assuming that the next four |
| // bytes of the string (src[0..3]) are four good data bytes |
| // (that is, no nulls, whitespace, padding chars, or illegal |
| // chars). We need to test src[0..2] for nulls individually |
| // before constructing temp to preserve the property that we |
| // never read past a null in the string (no matter how long |
| // szsrc claims the string is). |
| |
| if (!src[0] || !src[1] || !src[2] || |
| (temp = ((unbase64[static_cast<int>(src[0])] << 18) | |
| (unbase64[static_cast<int>(src[1])] << 12) | |
| (unbase64[static_cast<int>(src[2])] << 6) | |
| (unbase64[static_cast<int>(src[3])]))) & 0x80000000) { |
| // Iff any of those four characters was bad (null, illegal, |
| // whitespace, padding), then temp's high bit will be set |
| // (because unbase64[] is -1 for all bad characters). |
| // |
| // We'll back up and resort to the slower decoder, which knows |
| // how to handle those cases. |
| |
| GET_INPUT(first, 4); |
| temp = decode; |
| GET_INPUT(second, 3); |
| temp = (temp << 6) | decode; |
| GET_INPUT(third, 2); |
| temp = (temp << 6) | decode; |
| GET_INPUT(fourth, 1); |
| temp = (temp << 6) | decode; |
| } else { |
| // We really did have four good data bytes, so advance four |
| // characters in the string. |
| |
| szsrc -= 4; |
| src += 4; |
| decode = -1; |
| ch = '\0'; |
| } |
| |
| // temp has 24 bits of input, so write that out as three bytes. |
| |
| if (destidx+3 > szdest) return -1; |
| dest[destidx+2] = (char)temp; |
| temp >>= 8; |
| dest[destidx+1] = (char)temp; |
| temp >>= 8; |
| dest[destidx] = (char)temp; |
| destidx += 3; |
| } |
| } else { |
| while (szsrc >= 4) { |
| if (!src[0] || !src[1] || !src[2] || |
| (temp = ((unbase64[static_cast<int>(src[0])] << 18) | |
| (unbase64[static_cast<int>(src[1])] << 12) | |
| (unbase64[static_cast<int>(src[2])] << 6) | |
| (unbase64[static_cast<int>(src[3])]))) & 0x80000000) { |
| GET_INPUT(first_no_dest, 4); |
| GET_INPUT(second_no_dest, 3); |
| GET_INPUT(third_no_dest, 2); |
| GET_INPUT(fourth_no_dest, 1); |
| } else { |
| szsrc -= 4; |
| src += 4; |
| decode = -1; |
| ch = '\0'; |
| } |
| destidx += 3; |
| } |
| } |
| |
| #undef GET_INPUT |
| |
| // if the loop terminated because we read a bad character, return |
| // now. |
| if (decode < 0 && ch != '\0' && ch != kPad64 && !ascii_isspace((char)ch)) |
| return -1; |
| |
| if (ch == kPad64) { |
| // if we stopped by hitting an '=', un-read that character -- we'll |
| // look at it again when we count to check for the proper number of |
| // equals signs at the end. |
| ++szsrc; |
| --src; |
| } else { |
| // This loop consumes 1 input byte per iteration. It's used to |
| // clean up the 0-3 input bytes remaining when the first, faster |
| // loop finishes. 'temp' contains the data from 'state' input |
| // characters read by the first loop. |
| while (szsrc > 0) { |
| --szsrc; |
| ch = *src++; |
| decode = unbase64[ch]; |
| if (decode < 0) { |
| if (ascii_isspace((char)ch)) { |
| continue; |
| } else if (ch == '\0') { |
| break; |
| } else if (ch == kPad64) { |
| // back up one character; we'll read it again when we check |
| // for the correct number of equals signs at the end. |
| ++szsrc; |
| --src; |
| break; |
| } else { |
| return -1; |
| } |
| } |
| |
| // Each input character gives us six bits of output. |
| temp = (temp << 6) | decode; |
| ++state; |
| if (state == 4) { |
| // If we've accumulated 24 bits of output, write that out as |
| // three bytes. |
| if (dest) { |
| if (destidx+3 > szdest) return -1; |
| dest[destidx+2] = (char)temp; |
| temp >>= 8; |
| dest[destidx+1] = (char)temp; |
| temp >>= 8; |
| dest[destidx] = (char)temp; |
| } |
| destidx += 3; |
| state = 0; |
| temp = 0; |
| } |
| } |
| } |
| |
| // Process the leftover data contained in 'temp' at the end of the input. |
| int expected_equals = 0; |
| switch (state) { |
| case 0: |
| // Nothing left over; output is a multiple of 3 bytes. |
| break; |
| |
| case 1: |
| // Bad input; we have 6 bits left over. |
| return -1; |
| |
| case 2: |
| // Produce one more output byte from the 12 input bits we have left. |
| if (dest) { |
| if (destidx+1 > szdest) return -1; |
| temp >>= 4; |
| dest[destidx] = (char)temp; |
| } |
| ++destidx; |
| expected_equals = 2; |
| break; |
| |
| case 3: |
| // Produce two more output bytes from the 18 input bits we have left. |
| if (dest) { |
| if (destidx+2 > szdest) return -1; |
| temp >>= 2; |
| dest[destidx+1] = (char)temp; |
| temp >>= 8; |
| dest[destidx] = (char)temp; |
| } |
| destidx += 2; |
| expected_equals = 1; |
| break; |
| |
| default: |
| // state should have no other values at this point. |
| fprintf(stdout, "This can't happen; base64 decoder state = %d", state); |
| } |
| |
| // The remainder of the string should be all whitespace, mixed with |
| // exactly 0 equals signs, or exactly 'expected_equals' equals |
| // signs. (Always accepting 0 equals signs is a google extension |
| // not covered in the RFC.) |
| |
| int equals = 0; |
| while (szsrc > 0 && *src) { |
| if (*src == kPad64) |
| ++equals; |
| else if (!ascii_isspace(*src)) |
| return -1; |
| --szsrc; |
| ++src; |
| } |
| |
| return (equals == 0 || equals == expected_equals) ? destidx : -1; |
| } |
| |
| int Base64Unescape(const char *src, int szsrc, char *dest, int szdest) { |
| static const signed char UnBase64[] = { |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, 62/*+*/, -1, -1, -1, 63/*/ */, |
| 52/*0*/, 53/*1*/, 54/*2*/, 55/*3*/, 56/*4*/, 57/*5*/, 58/*6*/, 59/*7*/, |
| 60/*8*/, 61/*9*/, -1, -1, -1, -1, -1, -1, |
| -1, 0/*A*/, 1/*B*/, 2/*C*/, 3/*D*/, 4/*E*/, 5/*F*/, 6/*G*/, |
| 7/*H*/, 8/*I*/, 9/*J*/, 10/*K*/, 11/*L*/, 12/*M*/, 13/*N*/, 14/*O*/, |
| 15/*P*/, 16/*Q*/, 17/*R*/, 18/*S*/, 19/*T*/, 20/*U*/, 21/*V*/, 22/*W*/, |
| 23/*X*/, 24/*Y*/, 25/*Z*/, -1, -1, -1, -1, -1, |
| -1, 26/*a*/, 27/*b*/, 28/*c*/, 29/*d*/, 30/*e*/, 31/*f*/, 32/*g*/, |
| 33/*h*/, 34/*i*/, 35/*j*/, 36/*k*/, 37/*l*/, 38/*m*/, 39/*n*/, 40/*o*/, |
| 41/*p*/, 42/*q*/, 43/*r*/, 44/*s*/, 45/*t*/, 46/*u*/, 47/*v*/, 48/*w*/, |
| 49/*x*/, 50/*y*/, 51/*z*/, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1 |
| }; |
| // The above array was generated by the following code |
| // #include <sys/time.h> |
| // #include <stdlib.h> |
| // #include <string.h> |
| // main() |
| // { |
| // static const char Base64[] = |
| // "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
| // char *pos; |
| // int idx, i, j; |
| // printf(" "); |
| // for (i = 0; i < 255; i += 8) { |
| // for (j = i; j < i + 8; j++) { |
| // pos = strchr(Base64, j); |
| // if ((pos == NULL) || (j == 0)) |
| // idx = -1; |
| // else |
| // idx = pos - Base64; |
| // if (idx == -1) |
| // printf(" %2d, ", idx); |
| // else |
| // printf(" %2d/*%c*/,", idx, j); |
| // } |
| // printf("\n "); |
| // } |
| // } |
| |
| return Base64UnescapeInternal(src, szsrc, dest, szdest, UnBase64); |
| } |
| |
| bool Base64Unescape(const char *src, int slen, string* dest) { |
| // Determine the size of the output string. Base64 encodes every 3 bytes into |
| // 4 characters. any leftover chars are added directly for good measure. |
| // This is documented in the base64 RFC: http://www.ietf.org/rfc/rfc3548.txt |
| const int dest_len = 3 * (slen / 4) + (slen % 4); |
| |
| dest->resize(dest_len); |
| |
| // We are getting the destination buffer by getting the beginning of the |
| // string and converting it into a char *. |
| const int len = Base64Unescape(src, slen, |
| string_as_array(dest), dest->size()); |
| if (len < 0) { |
| return false; |
| } |
| |
| // could be shorter if there was padding |
| assert(len <= dest_len); |
| dest->resize(len); |
| |
| return true; |
| } |
| |
| // Base64Escape |
| // |
| // NOTE: We have to use an unsigned type for src because code built |
| // in the the /google tree treats characters as signed unless |
| // otherwised specified. |
| // |
| // TODO(who?): Move this function to use the char* type for "src" |
| int Base64EscapeInternal(const unsigned char *src, int szsrc, |
| char *dest, int szdest, const char *base64, |
| bool do_padding) { |
| static const char kPad64 = '='; |
| |
| if (szsrc <= 0) return 0; |
| |
| char *cur_dest = dest; |
| const unsigned char *cur_src = src; |
| |
| // Three bytes of data encodes to four characters of cyphertext. |
| // So we can pump through three-byte chunks atomically. |
| while (szsrc > 2) { /* keep going until we have less than 24 bits */ |
| if ((szdest -= 4) < 0) return 0; |
| cur_dest[0] = base64[cur_src[0] >> 2]; |
| cur_dest[1] = base64[((cur_src[0] & 0x03) << 4) + (cur_src[1] >> 4)]; |
| cur_dest[2] = base64[((cur_src[1] & 0x0f) << 2) + (cur_src[2] >> 6)]; |
| cur_dest[3] = base64[cur_src[2] & 0x3f]; |
| |
| cur_dest += 4; |
| cur_src += 3; |
| szsrc -= 3; |
| } |
| |
| /* now deal with the tail (<=2 bytes) */ |
| switch (szsrc) { |
| case 0: |
| // Nothing left; nothing more to do. |
| break; |
| case 1: |
| // One byte left: this encodes to two characters, and (optionally) |
| // two pad characters to round out the four-character cypherblock. |
| if ((szdest -= 2) < 0) return 0; |
| cur_dest[0] = base64[cur_src[0] >> 2]; |
| cur_dest[1] = base64[(cur_src[0] & 0x03) << 4]; |
| cur_dest += 2; |
| if (do_padding) { |
| if ((szdest -= 2) < 0) return 0; |
| cur_dest[0] = kPad64; |
| cur_dest[1] = kPad64; |
| cur_dest += 2; |
| } |
| break; |
| case 2: |
| // Two bytes left: this encodes to three characters, and (optionally) |
| // one pad character to round out the four-character cypherblock. |
| if ((szdest -= 3) < 0) return 0; |
| cur_dest[0] = base64[cur_src[0] >> 2]; |
| cur_dest[1] = base64[((cur_src[0] & 0x03) << 4) + (cur_src[1] >> 4)]; |
| cur_dest[2] = base64[(cur_src[1] & 0x0f) << 2]; |
| cur_dest += 3; |
| if (do_padding) { |
| if ((szdest -= 1) < 0) return 0; |
| cur_dest[0] = kPad64; |
| cur_dest += 1; |
| } |
| break; |
| default: |
| // Should not be reached: blocks of 3 bytes are handled |
| // in the while loop before this switch statement. |
| fprintf(stderr, "Logic problem? szsrc = %d", szsrc); |
| assert(false); |
| break; |
| } |
| return (cur_dest - dest); |
| } |
| |
| static const char kBase64Chars[] = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; |
| |
| static const char kWebSafeBase64Chars[] = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; |
| |
| int Base64Escape(const unsigned char *src, int szsrc, char *dest, int szdest) { |
| return Base64EscapeInternal(src, szsrc, dest, szdest, kBase64Chars, true); |
| } |
| |
| void Base64Escape(const unsigned char *src, int szsrc, |
| string* dest, bool do_padding) { |
| const int max_escaped_size = |
| CalculateBase64EscapedLen(szsrc, do_padding); |
| dest->clear(); |
| dest->resize(max_escaped_size + 1, '\0'); |
| const int escaped_len = Base64EscapeInternal(src, szsrc, |
| &*dest->begin(), dest->size(), |
| kBase64Chars, |
| do_padding); |
| assert(max_escaped_size <= escaped_len); |
| dest->resize(escaped_len); |
| } |
| |
| void Base64Escape(const string& src, string* dest) { |
| Base64Escape(reinterpret_cast<const unsigned char*>(src.c_str()), |
| src.size(), dest, true); |
| } |
| |
| //////////////////////////////////////////////////// |
| // WebSafe methods |
| //////////////////////////////////////////////////// |
| |
| int WebSafeBase64Unescape(const char *src, int szsrc, char *dest, int szdest) { |
| static const signed char UnBase64[] = { |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, 62/*-*/, -1, -1, |
| 52/*0*/, 53/*1*/, 54/*2*/, 55/*3*/, 56/*4*/, 57/*5*/, 58/*6*/, 59/*7*/, |
| 60/*8*/, 61/*9*/, -1, -1, -1, -1, -1, -1, |
| -1, 0/*A*/, 1/*B*/, 2/*C*/, 3/*D*/, 4/*E*/, 5/*F*/, 6/*G*/, |
| 7/*H*/, 8/*I*/, 9/*J*/, 10/*K*/, 11/*L*/, 12/*M*/, 13/*N*/, 14/*O*/, |
| 15/*P*/, 16/*Q*/, 17/*R*/, 18/*S*/, 19/*T*/, 20/*U*/, 21/*V*/, 22/*W*/, |
| 23/*X*/, 24/*Y*/, 25/*Z*/, -1, -1, -1, -1, 63/*_*/, |
| -1, 26/*a*/, 27/*b*/, 28/*c*/, 29/*d*/, 30/*e*/, 31/*f*/, 32/*g*/, |
| 33/*h*/, 34/*i*/, 35/*j*/, 36/*k*/, 37/*l*/, 38/*m*/, 39/*n*/, 40/*o*/, |
| 41/*p*/, 42/*q*/, 43/*r*/, 44/*s*/, 45/*t*/, 46/*u*/, 47/*v*/, 48/*w*/, |
| 49/*x*/, 50/*y*/, 51/*z*/, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1 |
| }; |
| // The above array was generated by the following code |
| // #include <sys/time.h> |
| // #include <stdlib.h> |
| // #include <string.h> |
| // main() |
| // { |
| // static const char Base64[] = |
| // "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"; |
| // char *pos; |
| // int idx, i, j; |
| // printf(" "); |
| // for (i = 0; i < 255; i += 8) { |
| // for (j = i; j < i + 8; j++) { |
| // pos = strchr(Base64, j); |
| // if ((pos == NULL) || (j == 0)) |
| // idx = -1; |
| // else |
| // idx = pos - Base64; |
| // if (idx == -1) |
| // printf(" %2d, ", idx); |
| // else |
| // printf(" %2d/*%c*/,", idx, j); |
| // } |
| // printf("\n "); |
| // } |
| // } |
| |
| return Base64UnescapeInternal(src, szsrc, dest, szdest, UnBase64); |
| } |
| |
| bool WebSafeBase64Unescape(const char *src, int slen, string* dest) { |
| int dest_len = 3 * (slen / 4) + (slen % 4); |
| dest->clear(); |
| dest->resize(dest_len); |
| int len = WebSafeBase64Unescape(src, slen, &*dest->begin(), dest->size()); |
| if (len < 0) { |
| dest->clear(); |
| return false; |
| } |
| // could be shorter if there was padding |
| assert(len <= dest_len); |
| dest->resize(len); |
| return true; |
| } |
| |
| bool WebSafeBase64Unescape(const string& src, string* dest) { |
| return WebSafeBase64Unescape(src.data(), src.size(), dest); |
| } |
| |
| int WebSafeBase64Escape(const unsigned char *src, int szsrc, char *dest, |
| int szdest, bool do_padding) { |
| return Base64EscapeInternal(src, szsrc, dest, szdest, |
| kWebSafeBase64Chars, do_padding); |
| } |
| |
| void WebSafeBase64Escape(const unsigned char *src, int szsrc, |
| string *dest, bool do_padding) { |
| const int max_escaped_size = |
| CalculateBase64EscapedLen(szsrc, do_padding); |
| dest->clear(); |
| dest->resize(max_escaped_size + 1, '\0'); |
| const int escaped_len = Base64EscapeInternal(src, szsrc, |
| &*dest->begin(), dest->size(), |
| kWebSafeBase64Chars, |
| do_padding); |
| assert(max_escaped_size <= escaped_len); |
| dest->resize(escaped_len); |
| } |
| |
| void WebSafeBase64EscapeInternal(const string& src, |
| string* dest, |
| bool do_padding) { |
| int encoded_len = CalculateBase64EscapedLen(src.size()); |
| scoped_array<char> buf(new char[encoded_len]); |
| int len = WebSafeBase64Escape(reinterpret_cast<const unsigned char*>(src.c_str()), |
| src.size(), buf.get(), |
| encoded_len, do_padding); |
| dest->assign(buf.get(), len); |
| } |
| |
| void WebSafeBase64Escape(const string& src, string* dest) { |
| WebSafeBase64EscapeInternal(src, dest, false); |
| } |
| |
| void WebSafeBase64EscapeWithPadding(const string& src, string* dest) { |
| WebSafeBase64EscapeInternal(src, dest, true); |
| } |
| |
| } // namespace strings |
