| // Copyright 2008 Google Inc. All Rights Reserved. |
| // Authors: Numerous. See the .h for contact people. |
| |
| #include "gutil/strings/escaping.h" |
| |
| #include <assert.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <glog/logging.h> |
| #include <limits> |
| #include <ostream> |
| |
| #include "common/exception.h" |
| |
| using std::numeric_limits; |
| #include <vector> |
| |
| using std::vector; |
| |
| #include "gutil/charmap.h" |
| #include "gutil/gscoped_ptr.h" |
| #include "gutil/integral_types.h" |
| #include "gutil/port.h" |
| #include "gutil/stl_util.h" |
| #include "gutil/utf/utf.h" // for runetochar |
| #include "gutil/strings/strcat.h" |
| |
| namespace strings { |
| |
| // These are used for the leave_nulls_escaped argument to CUnescapeInternal(). |
| static bool kUnescapeNulls = false; |
| static bool kLeaveNullsEscaped = true; |
| |
| // ---------------------------------------------------------------------- |
| // EscapeStrForCSV() |
| // Escapes the quotes in 'src' by doubling them. This is necessary |
| // for generating CSV files (see SplitCSVLine). |
| // Returns the number of characters written into dest (not counting |
| // the \0) or -1 if there was insufficient space. Dest could end up |
| // twice as long as src. |
| // |
| // Example: [some "string" to test] --> [some ""string"" to test] |
| // ---------------------------------------------------------------------- |
| int EscapeStrForCSV(const char* src, char* dest, int dest_len) { |
| int used = 0; |
| |
| while (true) { |
| if (*src == '\0' && used < dest_len) { |
| dest[used] = '\0'; |
| return used; |
| } |
| |
| if (used + 1 >= dest_len) // +1 because we might require two characters |
| return -1; |
| |
| if (*src == '"') dest[used++] = '"'; |
| |
| dest[used++] = *src++; |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| // UnescapeCEscapeSequences() |
| // This does all the unescaping that C does: \ooo, \r, \n, etc |
| // Returns length of resulting string. |
| // The implementation of \x parses any positive number of hex digits, |
| // but it is an error if the value requires more than 8 bits, and the |
| // result is truncated to 8 bits. The same is true for octals. |
| // |
| // The second call stores its errors in a supplied string vector. |
| // If the string vector pointer is NULL, it reports the errors with LOG(). |
| // |
| // *** DEPRECATED: Use CUnescape() in new code *** |
| // |
| // NOTE: any changes to this function must also be reflected in the newer |
| // CUnescape(). |
| // ---------------------------------------------------------------------- |
| |
| #define IS_OCTAL_DIGIT(c) (((c) >= '0') && ((c) <= '7')) |
| |
| int UnescapeCEscapeSequences(const char* source, char* dest) { |
| return UnescapeCEscapeSequences(source, dest, nullptr); |
| } |
| |
| int UnescapeCEscapeSequences(const char* source, char* dest, vector<string>* errors) { |
| char* d = dest; |
| const char* p = source; |
| |
| // Small optimization for case where source = dest and there's no escaping |
| while (p == d && *p != '\0' && *p != '\\') p++, d++; |
| |
| while (*p != '\0') { |
| if (*p != '\\') { |
| *d++ = *p++; |
| } else { |
| switch (*++p) { // skip past the '\\' |
| case '\0': |
| LOG_STRING(ERROR, errors) << "String cannot end with \\"; |
| *d = '\0'; |
| return d - dest; // we're done with p |
| case 'a': |
| *d++ = '\a'; |
| break; |
| case 'b': |
| *d++ = '\b'; |
| break; |
| case 'f': |
| *d++ = '\f'; |
| break; |
| case 'n': |
| *d++ = '\n'; |
| break; |
| case 'r': |
| *d++ = '\r'; |
| break; |
| case 't': |
| *d++ = '\t'; |
| break; |
| case 'v': |
| *d++ = '\v'; |
| break; |
| case '\\': |
| *d++ = '\\'; |
| break; |
| case '?': |
| *d++ = '\?'; |
| break; // \? Who knew? |
| case '\'': |
| *d++ = '\''; |
| break; |
| case '"': |
| *d++ = '\"'; |
| break; |
| case '0': |
| case '1': |
| case '2': |
| case '3': // octal digit: 1 to 3 digits |
| case '4': |
| case '5': |
| case '6': |
| case '7': { |
| const char* octal_start = p; |
| unsigned int ch = *p - '0'; |
| if (IS_OCTAL_DIGIT(p[1])) ch = ch * 8 + *++p - '0'; |
| if (IS_OCTAL_DIGIT(p[1])) // safe (and easy) to do this twice |
| ch = ch * 8 + *++p - '0'; // now points at last digit |
| if (ch > 0xFF) |
| LOG_STRING(ERROR, errors) << "Value of " |
| << "\\" << string(octal_start, p + 1 - octal_start) |
| << " exceeds 8 bits"; |
| *d++ = ch; |
| break; |
| } |
| case 'x': |
| case 'X': { |
| if (!ascii_isxdigit(p[1])) { |
| if (p[1] == '\0') { |
| LOG_STRING(ERROR, errors) << "String cannot end with \\x"; |
| } else { |
| LOG_STRING(ERROR, errors) |
| << "\\x cannot be followed by a non-hex digit: \\" << *p << p[1]; |
| } |
| break; |
| } |
| unsigned int ch = 0; |
| const char* hex_start = p; |
| while (ascii_isxdigit(p[1])) // arbitrarily many hex digits |
| ch = (ch << 4) + hex_digit_to_int(*++p); |
| if (ch > 0xFF) |
| LOG_STRING(ERROR, errors) |
| << "Value of " |
| << "\\" << string(hex_start, p + 1 - hex_start) << " exceeds 8 bits"; |
| *d++ = ch; |
| break; |
| } |
| case 'u': { |
| // \uhhhh => convert 4 hex digits to UTF-8 |
| char32 rune = 0; |
| const char* hex_start = p; |
| for (int i = 0; i < 4; ++i) { |
| if (ascii_isxdigit(p[1])) { // Look one char ahead. |
| rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p. |
| } else { |
| LOG_STRING(ERROR, errors) << "\\u must be followed by 4 hex digits: \\" |
| << string(hex_start, p + 1 - hex_start); |
| break; |
| } |
| } |
| d += runetochar(d, &rune); |
| break; |
| } |
| case 'U': { |
| // \Uhhhhhhhh => convert 8 hex digits to UTF-8 |
| char32 rune = 0; |
| const char* hex_start = p; |
| for (int i = 0; i < 8; ++i) { |
| if (ascii_isxdigit(p[1])) { // Look one char ahead. |
| // Don't change rune until we're sure this |
| // is within the Unicode limit, but do advance p. |
| char32 newrune = (rune << 4) + hex_digit_to_int(*++p); |
| if (newrune > 0x10FFFF) { |
| LOG_STRING(ERROR, errors) |
| << "Value of \\" << string(hex_start, p + 1 - hex_start) |
| << " exceeds Unicode limit (0x10FFFF)"; |
| break; |
| } else { |
| rune = newrune; |
| } |
| } else { |
| LOG_STRING(ERROR, errors) << "\\U must be followed by 8 hex digits: \\" |
| << string(hex_start, p + 1 - hex_start); |
| break; |
| } |
| } |
| d += runetochar(d, &rune); |
| break; |
| } |
| default: |
| LOG_STRING(ERROR, errors) << "Unknown escape sequence: \\" << *p; |
| } |
| p++; // read past letter we escaped |
| } |
| } |
| *d = '\0'; |
| return d - dest; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // UnescapeCEscapeString() |
| // This does the same thing as UnescapeCEscapeSequences, but creates |
| // a new string. The caller does not need to worry about allocating |
| // a dest buffer. This should be used for non performance critical |
| // tasks such as printing debug messages. It is safe for src and dest |
| // to be the same. |
| // |
| // The second call stores its errors in a supplied string vector. |
| // If the string vector pointer is NULL, it reports the errors with LOG(). |
| // |
| // In the first and second calls, the length of dest is returned. In the |
| // the third call, the new string is returned. |
| // |
| // *** DEPRECATED: Use CUnescape() in new code *** |
| // |
| // ---------------------------------------------------------------------- |
| int UnescapeCEscapeString(const string& src, string* dest) { |
| return UnescapeCEscapeString(src, dest, nullptr); |
| } |
| |
| int UnescapeCEscapeString(const string& src, string* dest, vector<string>* errors) { |
| CHECK(dest); |
| dest->resize(src.size() + 1); |
| int len = UnescapeCEscapeSequences(src.c_str(), const_cast<char*>(dest->data()), errors); |
| dest->resize(len); |
| return len; |
| } |
| |
| string UnescapeCEscapeString(const string& src) { |
| gscoped_array<char> unescaped(new char[src.size() + 1]); |
| int len = UnescapeCEscapeSequences(src.c_str(), unescaped.get(), nullptr); |
| return string(unescaped.get(), len); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CUnescapeInternal() |
| // Implements both CUnescape() and CUnescapeForNullTerminatedString(). |
| // |
| // Unescapes C escape sequences and is the reverse of CEscape(). |
| // |
| // If 'source' is valid, stores the unescaped string and its size in |
| // 'dest' and 'dest_len' respectively, and returns true. Otherwise |
| // returns false and optionally stores the error description in |
| // 'error'. Set 'error' to NULL to disable error reporting. |
| // |
| // 'dest' should point to a buffer that is at least as big as 'source'. |
| // 'source' and 'dest' may be the same. |
| // |
| // NOTE: any changes to this function must also be reflected in the older |
| // UnescapeCEscapeSequences(). |
| // ---------------------------------------------------------------------- |
| static bool CUnescapeInternal(const StringPiece& source, bool leave_nulls_escaped, char* dest, |
| int* dest_len, string* error) { |
| char* d = dest; |
| const char* p = source.data(); |
| const char* end = source.end(); |
| const char* last_byte = end - 1; |
| |
| // Small optimization for case where source = dest and there's no escaping |
| while (p == d && p < end && *p != '\\') p++, d++; |
| |
| while (p < end) { |
| if (*p != '\\') { |
| *d++ = *p++; |
| } else { |
| if (++p > last_byte) { // skip past the '\\' |
| if (error) *error = "String cannot end with \\"; |
| return false; |
| } |
| switch (*p) { |
| case 'a': |
| *d++ = '\a'; |
| break; |
| case 'b': |
| *d++ = '\b'; |
| break; |
| case 'f': |
| *d++ = '\f'; |
| break; |
| case 'n': |
| *d++ = '\n'; |
| break; |
| case 'r': |
| *d++ = '\r'; |
| break; |
| case 't': |
| *d++ = '\t'; |
| break; |
| case 'v': |
| *d++ = '\v'; |
| break; |
| case '\\': |
| *d++ = '\\'; |
| break; |
| case '?': |
| *d++ = '\?'; |
| break; // \? Who knew? |
| case '\'': |
| *d++ = '\''; |
| break; |
| case '"': |
| *d++ = '\"'; |
| break; |
| case '0': |
| case '1': |
| case '2': |
| case '3': // octal digit: 1 to 3 digits |
| case '4': |
| case '5': |
| case '6': |
| case '7': { |
| const char* octal_start = p; |
| unsigned int ch = *p - '0'; |
| if (p < last_byte && IS_OCTAL_DIGIT(p[1])) ch = ch * 8 + *++p - '0'; |
| if (p < last_byte && IS_OCTAL_DIGIT(p[1])) |
| ch = ch * 8 + *++p - '0'; // now points at last digit |
| if (ch > 0xff) { |
| if (error) { |
| *error = "Value of \\" + string(octal_start, p + 1 - octal_start) + |
| " exceeds 0xff"; |
| } |
| return false; |
| } |
| if ((ch == 0) && leave_nulls_escaped) { |
| // Copy the escape sequence for the null character |
| const int octal_size = p + 1 - octal_start; |
| *d++ = '\\'; |
| memcpy(d, octal_start, octal_size); |
| d += octal_size; |
| break; |
| } |
| *d++ = ch; |
| break; |
| } |
| case 'x': |
| case 'X': { |
| if (p >= last_byte) { |
| if (error) *error = "String cannot end with \\x"; |
| return false; |
| } else if (!ascii_isxdigit(p[1])) { |
| if (error) *error = "\\x cannot be followed by a non-hex digit"; |
| return false; |
| } |
| unsigned int ch = 0; |
| const char* hex_start = p; |
| while (p < last_byte && ascii_isxdigit(p[1])) |
| // Arbitrarily many hex digits |
| ch = (ch << 4) + hex_digit_to_int(*++p); |
| if (ch > 0xFF) { |
| if (error) { |
| *error = "Value of \\" + string(hex_start, p + 1 - hex_start) + |
| " exceeds 0xff"; |
| } |
| return false; |
| } |
| if ((ch == 0) && leave_nulls_escaped) { |
| // Copy the escape sequence for the null character |
| const int hex_size = p + 1 - hex_start; |
| *d++ = '\\'; |
| memcpy(d, hex_start, hex_size); |
| d += hex_size; |
| break; |
| } |
| *d++ = ch; |
| break; |
| } |
| case 'u': { |
| // \uhhhh => convert 4 hex digits to UTF-8 |
| char32 rune = 0; |
| const char* hex_start = p; |
| if (p + 4 >= end) { |
| if (error) { |
| *error = "\\u must be followed by 4 hex digits: \\" + |
| string(hex_start, p + 1 - hex_start); |
| } |
| return false; |
| } |
| for (int i = 0; i < 4; ++i) { |
| // Look one char ahead. |
| if (ascii_isxdigit(p[1])) { |
| rune = (rune << 4) + hex_digit_to_int(*++p); // Advance p. |
| } else { |
| if (error) { |
| *error = "\\u must be followed by 4 hex digits: \\" + |
| string(hex_start, p + 1 - hex_start); |
| } |
| return false; |
| } |
| } |
| if ((rune == 0) && leave_nulls_escaped) { |
| // Copy the escape sequence for the null character |
| *d++ = '\\'; |
| memcpy(d, hex_start, 5); // u0000 |
| d += 5; |
| break; |
| } |
| d += runetochar(d, &rune); |
| break; |
| } |
| case 'U': { |
| // \Uhhhhhhhh => convert 8 hex digits to UTF-8 |
| char32 rune = 0; |
| const char* hex_start = p; |
| if (p + 8 >= end) { |
| if (error) { |
| *error = "\\U must be followed by 8 hex digits: \\" + |
| string(hex_start, p + 1 - hex_start); |
| } |
| return false; |
| } |
| for (int i = 0; i < 8; ++i) { |
| // Look one char ahead. |
| if (ascii_isxdigit(p[1])) { |
| // Don't change rune until we're sure this |
| // is within the Unicode limit, but do advance p. |
| char32 newrune = (rune << 4) + hex_digit_to_int(*++p); |
| if (newrune > 0x10FFFF) { |
| if (error) { |
| *error = "Value of \\" + string(hex_start, p + 1 - hex_start) + |
| " exceeds Unicode limit (0x10FFFF)"; |
| } |
| return false; |
| } else { |
| rune = newrune; |
| } |
| } else { |
| if (error) { |
| *error = "\\U must be followed by 8 hex digits: \\" + |
| string(hex_start, p + 1 - hex_start); |
| } |
| return false; |
| } |
| } |
| if ((rune == 0) && leave_nulls_escaped) { |
| // Copy the escape sequence for the null character |
| *d++ = '\\'; |
| memcpy(d, hex_start, 9); // U00000000 |
| d += 9; |
| break; |
| } |
| d += runetochar(d, &rune); |
| break; |
| } |
| default: { |
| if (error) *error = string("Unknown escape sequence: \\") + *p; |
| return false; |
| } |
| } |
| p++; // read past letter we escaped |
| } |
| } |
| *dest_len = d - dest; |
| return true; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CUnescapeInternal() |
| // |
| // Same as above but uses a C++ string for output. 'source' and 'dest' |
| // may be the same. |
| // ---------------------------------------------------------------------- |
| bool CUnescapeInternal(const StringPiece& source, bool leave_nulls_escaped, string* dest, |
| string* error) { |
| dest->resize(source.size()); |
| int dest_size; |
| if (!CUnescapeInternal(source, leave_nulls_escaped, const_cast<char*>(dest->data()), &dest_size, |
| error)) { |
| return false; |
| } |
| dest->resize(dest_size); |
| return true; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CUnescape() |
| // |
| // See CUnescapeInternal() for implementation details. |
| // ---------------------------------------------------------------------- |
| bool CUnescape(const StringPiece& source, char* dest, int* dest_len, string* error) { |
| return CUnescapeInternal(source, kUnescapeNulls, dest, dest_len, error); |
| } |
| |
| bool CUnescape(const StringPiece& source, string* dest, string* error) { |
| return CUnescapeInternal(source, kUnescapeNulls, dest, error); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CUnescapeForNullTerminatedString() |
| // |
| // See CUnescapeInternal() for implementation details. |
| // ---------------------------------------------------------------------- |
| bool CUnescapeForNullTerminatedString(const StringPiece& source, char* dest, int* dest_len, |
| string* error) { |
| return CUnescapeInternal(source, kLeaveNullsEscaped, dest, dest_len, error); |
| } |
| |
| bool CUnescapeForNullTerminatedString(const StringPiece& source, string* dest, string* error) { |
| return CUnescapeInternal(source, kLeaveNullsEscaped, dest, error); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CEscapeString() |
| // CHexEscapeString() |
| // Utf8SafeCEscapeString() |
| // Utf8SafeCHexEscapeString() |
| // Copies 'src' to 'dest', escaping dangerous characters using |
| // C-style escape sequences. This is very useful for preparing query |
| // flags. 'src' and 'dest' should not overlap. The 'Hex' version uses |
| // hexadecimal rather than octal sequences. The 'Utf8Safe' version doesn't |
| // touch UTF-8 bytes. |
| // Returns the number of bytes written to 'dest' (not including the \0) |
| // or -1 if there was insufficient space. |
| // |
| // Currently only \n, \r, \t, ", ', \ and !ascii_isprint() chars are escaped. |
| // ---------------------------------------------------------------------- |
| int CEscapeInternal(const char* src, int src_len, char* dest, int dest_len, bool use_hex, |
| bool utf8_safe) { |
| const char* src_end = src + src_len; |
| int used = 0; |
| bool last_hex_escape = false; // true if last output char was \xNN |
| |
| for (; src < src_end; src++) { |
| if (dest_len - used < 2) // Need space for two letter escape |
| return -1; |
| |
| bool is_hex_escape = false; |
| switch (*src) { |
| case '\n': |
| dest[used++] = '\\'; |
| dest[used++] = 'n'; |
| break; |
| case '\r': |
| dest[used++] = '\\'; |
| dest[used++] = 'r'; |
| break; |
| case '\t': |
| dest[used++] = '\\'; |
| dest[used++] = 't'; |
| break; |
| case '\"': |
| dest[used++] = '\\'; |
| dest[used++] = '\"'; |
| break; |
| case '\'': |
| dest[used++] = '\\'; |
| dest[used++] = '\''; |
| break; |
| case '\\': |
| dest[used++] = '\\'; |
| dest[used++] = '\\'; |
| break; |
| default: |
| // Note that if we emit \xNN and the src character after that is a hex |
| // digit then that digit must be escaped too to prevent it being |
| // interpreted as part of the character code by C. |
| if ((!utf8_safe || *src < 0x80) && |
| (!ascii_isprint(*src) || (last_hex_escape && ascii_isxdigit(*src)))) { |
| if (dest_len - used < 4) // need space for 4 letter escape |
| return -1; |
| sprintf(dest + used, (use_hex ? "\\x%02x" : "\\%03o"), *src); |
| is_hex_escape = use_hex; |
| used += 4; |
| } else { |
| dest[used++] = *src; |
| break; |
| } |
| } |
| last_hex_escape = is_hex_escape; |
| } |
| |
| if (dest_len - used < 1) // make sure that there is room for \0 |
| return -1; |
| |
| dest[used] = '\0'; // doesn't count towards return value though |
| return used; |
| } |
| |
| int CEscapeString(const char* src, int src_len, char* dest, int dest_len) { |
| return CEscapeInternal(src, src_len, dest, dest_len, false, false); |
| } |
| |
| int CHexEscapeString(const char* src, int src_len, char* dest, int dest_len) { |
| return CEscapeInternal(src, src_len, dest, dest_len, true, false); |
| } |
| |
| int Utf8SafeCEscapeString(const char* src, int src_len, char* dest, int dest_len) { |
| return CEscapeInternal(src, src_len, dest, dest_len, false, true); |
| } |
| |
| int Utf8SafeCHexEscapeString(const char* src, int src_len, char* dest, int dest_len) { |
| return CEscapeInternal(src, src_len, dest, dest_len, true, true); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CEscape() |
| // CHexEscape() |
| // Utf8SafeCEscape() |
| // Utf8SafeCHexEscape() |
| // Copies 'src' to result, escaping dangerous characters using |
| // C-style escape sequences. This is very useful for preparing query |
| // flags. 'src' and 'dest' should not overlap. The 'Hex' version |
| // hexadecimal rather than octal sequences. The 'Utf8Safe' version |
| // doesn't touch UTF-8 bytes. |
| // |
| // Currently only \n, \r, \t, ", ', \ and !ascii_isprint() chars are escaped. |
| // ---------------------------------------------------------------------- |
| string CEscape(const StringPiece& src) { |
| const int dest_length = src.size() * 4 + 1; // Maximum possible expansion |
| gscoped_array<char> dest(new char[dest_length]); |
| const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, false, false); |
| DCHECK_GE(len, 0); |
| return string(dest.get(), len); |
| } |
| |
| string CHexEscape(const StringPiece& src) { |
| const int dest_length = src.size() * 4 + 1; // Maximum possible expansion |
| gscoped_array<char> dest(new char[dest_length]); |
| const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, true, false); |
| DCHECK_GE(len, 0); |
| return string(dest.get(), len); |
| } |
| |
| string Utf8SafeCEscape(const StringPiece& src) { |
| const int dest_length = src.size() * 4 + 1; // Maximum possible expansion |
| gscoped_array<char> dest(new char[dest_length]); |
| const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, false, true); |
| DCHECK_GE(len, 0); |
| return string(dest.get(), len); |
| } |
| |
| string Utf8SafeCHexEscape(const StringPiece& src) { |
| const int dest_length = src.size() * 4 + 1; // Maximum possible expansion |
| gscoped_array<char> dest(new char[dest_length]); |
| const int len = CEscapeInternal(src.data(), src.size(), dest.get(), dest_length, true, true); |
| DCHECK_GE(len, 0); |
| return string(dest.get(), len); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // BackslashEscape and BackslashUnescape |
| // ---------------------------------------------------------------------- |
| void BackslashEscape(const StringPiece& src, const strings::CharSet& to_escape, string* dest) { |
| dest->reserve(dest->size() + src.size()); |
| for (const char *p = src.data(), *end = src.data() + src.size(); p != end;) { |
| // Advance to next character we need to escape, or to end of source |
| const char* next = p; |
| while (next < end && !to_escape.Test(*next)) { |
| next++; |
| } |
| // Append the whole run of non-escaped chars |
| dest->append(p, next - p); |
| if (next == end) break; |
| // Char at *next needs to be escaped. Append backslash followed by *next |
| char c[2]; |
| c[0] = '\\'; |
| c[1] = *next; |
| dest->append(c, 2); |
| p = next + 1; |
| } |
| } |
| |
| void BackslashUnescape(const StringPiece& src, const strings::CharSet& to_unescape, string* dest) { |
| dest->reserve(dest->size() + src.size()); |
| bool escaped = false; |
| for (const char *p = src.data(), *end = src.data() + src.size(); p != end; ++p) { |
| if (escaped) { |
| if (!to_unescape.Test(*p)) { |
| // Keep the backslash |
| dest->push_back('\\'); |
| } |
| dest->push_back(*p); |
| escaped = false; |
| } else if (*p == '\\') { |
| escaped = true; |
| } else { |
| dest->push_back(*p); |
| } |
| } |
| } |
| |
| // ---------------------------------------------------------------------- |
| // int QuotedPrintableUnescape() |
| // |
| // Check out http://www.cis.ohio-state.edu/htbin/rfc/rfc2045.html for |
| // more details, only briefly implemented. But from the web... |
| // Quoted-printable is an encoding method defined in the MIME |
| // standard. It is used primarily to encode 8-bit text (such as text |
| // that includes foreign characters) into 7-bit US ASCII, creating a |
| // document that is mostly readable by humans, even in its encoded |
| // form. All MIME compliant applications can decode quoted-printable |
| // text, though they may not necessarily be able to properly display the |
| // document as it was originally intended. As quoted-printable encoding |
| // is implemented most commonly, printable ASCII characters (values 33 |
| // through 126, excluding 61), tabs and spaces that do not appear at the |
| // end of lines, and end-of-line characters are not encoded. Other |
| // characters are represented by an equal sign (=) immediately followed |
| // by that character's hexadecimal value. Lines that are longer than 76 |
| // characters are shortened by line breaks, with the equal sign marking |
| // where the breaks occurred. |
| // |
| // Note that QuotedPrintableUnescape is different from 'Q'-encoding as |
| // defined in rfc2047. In particular, This does not treat '_'s as spaces. |
| // See QEncodingUnescape(). |
| // ---------------------------------------------------------------------- |
| |
| int QuotedPrintableUnescape(const char* source, int slen, char* dest, int szdest) { |
| char* d = dest; |
| const char* p = source; |
| |
| while (p < source + slen && *p != '\0' && d < dest + szdest) { |
| switch (*p) { |
| case '=': |
| // If it's valid, convert to hex and insert or remove line-wrap. |
| // In the case of line-wrap removal, we allow LF as well as CRLF. |
| if (p < source + slen - 1) { |
| if (p[1] == '\n') { |
| p++; |
| } else if (p < source + slen - 2) { |
| if (ascii_isxdigit(p[1]) && ascii_isxdigit(p[2])) { |
| *d++ = hex_digit_to_int(p[1]) * 16 + hex_digit_to_int(p[2]); |
| p += 2; |
| } else if (p[1] == '\r' && p[2] == '\n') { |
| p += 2; |
| } |
| } |
| } |
| p++; |
| break; |
| default: |
| *d++ = *p++; |
| break; |
| } |
| } |
| return (d - dest); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // int QEncodingUnescape() |
| // |
| // This is very similar to QuotedPrintableUnescape except that we convert |
| // '_'s into spaces. (See RFC 2047) |
| // ---------------------------------------------------------------------- |
| int QEncodingUnescape(const char* source, int slen, char* dest, int szdest) { |
| char* d = dest; |
| const char* p = source; |
| |
| while (p < source + slen && *p != '\0' && d < dest + szdest) { |
| switch (*p) { |
| case '=': |
| // If it's valid, convert to hex and insert or remove line-wrap. |
| // In the case of line-wrap removal, the assumption is that this |
| // is an RFC-compliant message with lines terminated by CRLF. |
| if (p < source + slen - 2) { |
| if (ascii_isxdigit(p[1]) && ascii_isxdigit(p[2])) { |
| *d++ = hex_digit_to_int(p[1]) * 16 + hex_digit_to_int(p[2]); |
| p += 2; |
| } else if (p[1] == '\r' && p[2] == '\n') { |
| p += 2; |
| } |
| } |
| p++; |
| break; |
| case '_': // According to rfc2047, _'s are to be treated as spaces |
| *d++ = ' '; |
| p++; |
| break; |
| default: |
| *d++ = *p++; |
| break; |
| } |
| } |
| return (d - dest); |
| } |
| |
| int CalculateBase64EscapedLen(int input_len, bool do_padding) { |
| // Base64 encodes three bytes of input at a time. If the input is not |
| // divisible by three, we pad as appropriate. |
| // |
| // (from http://www.ietf.org/rfc/rfc3548.txt) |
| // Special processing is performed if fewer than 24 bits are available |
| // at the end of the data being encoded. A full encoding quantum is |
| // always completed at the end of a quantity. When fewer than 24 input |
| // bits are available in an input group, zero bits are added (on the |
| // right) to form an integral number of 6-bit groups. Padding at the |
| // end of the data is performed using the '=' character. Since all base |
| // 64 input is an integral number of octets, only the following cases |
| // can arise: |
| |
| // Base64 encodes each three bytes of input into four bytes of output. |
| int len = (input_len / 3) * 4; |
| |
| if (input_len % 3 == 0) { |
| // (from http://www.ietf.org/rfc/rfc3548.txt) |
| // (1) the final quantum of encoding input is an integral multiple of 24 |
| // bits; here, the final unit of encoded output will be an integral |
| // multiple of 4 characters with no "=" padding, |
| } else if (input_len % 3 == 1) { |
| // (from http://www.ietf.org/rfc/rfc3548.txt) |
| // (2) the final quantum of encoding input is exactly 8 bits; here, the |
| // final unit of encoded output will be two characters followed by two |
| // "=" padding characters, or |
| len += 2; |
| if (do_padding) { |
| len += 2; |
| } |
| } else { // (input_len % 3 == 2) |
| // (from http://www.ietf.org/rfc/rfc3548.txt) |
| // (3) the final quantum of encoding input is exactly 16 bits; here, the |
| // final unit of encoded output will be three characters followed by one |
| // "=" padding character. |
| len += 3; |
| if (do_padding) { |
| len += 1; |
| } |
| } |
| |
| assert(len >= input_len); // make sure we didn't overflow |
| 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. |
| // In the sorted variation, we instead use the mapping |
| // . maps to 0 |
| // 0-9 map to 1-10 |
| // A-Z map to 11-37 |
| // _ maps to 38 |
| // a-z map to 39-63 |
| // This mapping has the property that the output will be sorted in the same |
| // order as the input, i.e. a < b iff map(a) < map(b). It is web-safe and |
| // filename-safe. |
| // ---------------------------------------------------------------------- |
| |
| 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(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[src[0]] << 18) | (unbase64[src[1]] << 12) | |
| (unbase64[src[2]] << 6) | (unbase64[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] = temp; |
| temp >>= 8; |
| dest[destidx + 1] = temp; |
| temp >>= 8; |
| dest[destidx] = temp; |
| destidx += 3; |
| } |
| } else { |
| while (szsrc >= 4) { |
| if (!src[0] || !src[1] || !src[2] || |
| (temp = ((unbase64[src[0]] << 18) | (unbase64[src[1]] << 12) | |
| (unbase64[src[2]] << 6) | (unbase64[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(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(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] = temp; |
| temp >>= 8; |
| dest[destidx + 1] = temp; |
| temp >>= 8; |
| dest[destidx] = 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] = 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] = temp; |
| temp >>= 8; |
| dest[destidx] = temp; |
| } |
| destidx += 2; |
| expected_equals = 1; |
| break; |
| |
| default: |
| // state should have no other values at this point. |
| throw doris::Exception( |
| doris::Status::FatalError("This can't happen; base64 decoder state = {}", 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; |
| } |
| |
| // The arrays below were 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 "); |
| // } |
| // } |
| // |
| // where the value of "Base64[]" was replaced by one of the base-64 conversion |
| // tables from the functions below. |
| static const signed char kUnBase64[] = { |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -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*/, |
| 07 /*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}; |
| static const signed char kUnWebSafeBase64[] = { |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -1, -1, -1, -1, -1, -1, |
| -1, -1, -1, -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*/, |
| 07 /*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}; |
| |
| int Base64Unescape(const char* src, int szsrc, char* dest, int szdest) { |
| return Base64UnescapeInternal(src, szsrc, dest, szdest, kUnBase64); |
| } |
| |
| int WebSafeBase64Unescape(const char* src, int szsrc, char* dest, int szdest) { |
| return Base64UnescapeInternal(src, szsrc, dest, szdest, kUnWebSafeBase64); |
| } |
| |
| static bool Base64UnescapeInternal(const char* src, int slen, string* dest, |
| const signed char* unbase64) { |
| // 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->clear(); |
| 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 = |
| Base64UnescapeInternal(src, slen, string_as_array(dest), dest->size(), unbase64); |
| if (len < 0) { |
| dest->clear(); |
| return false; |
| } |
| |
| // could be shorter if there was padding |
| DCHECK_LE(len, dest_len); |
| dest->resize(len); |
| |
| return true; |
| } |
| |
| bool Base64Unescape(const char* src, int slen, string* dest) { |
| return Base64UnescapeInternal(src, slen, dest, kUnBase64); |
| } |
| |
| bool WebSafeBase64Unescape(const char* src, int slen, string* dest) { |
| return Base64UnescapeInternal(src, slen, dest, kUnWebSafeBase64); |
| } |
| |
| 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. |
| LOG_ASSERT(false) << "Logic problem? szsrc = " << szsrc; |
| 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); |
| } |
| 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 Base64EscapeInternal(const unsigned char* src, int szsrc, string* dest, bool do_padding, |
| const char* base64_chars) { |
| const int calc_escaped_size = CalculateBase64EscapedLen(szsrc, do_padding); |
| dest->clear(); |
| dest->resize(calc_escaped_size, '\0'); |
| const int escaped_len = Base64EscapeInternal(src, szsrc, string_as_array(dest), dest->size(), |
| base64_chars, do_padding); |
| DCHECK_EQ(calc_escaped_size, escaped_len); |
| } |
| |
| void Base64Escape(const unsigned char* src, int szsrc, string* dest, bool do_padding) { |
| Base64EscapeInternal(src, szsrc, dest, do_padding, kBase64Chars); |
| } |
| |
| void WebSafeBase64Escape(const unsigned char* src, int szsrc, string* dest, bool do_padding) { |
| Base64EscapeInternal(src, szsrc, dest, do_padding, kWebSafeBase64Chars); |
| } |
| |
| void Base64Escape(const string& src, string* dest) { |
| Base64Escape(reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, true); |
| } |
| |
| void WebSafeBase64Escape(const string& src, string* dest) { |
| WebSafeBase64Escape(reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, |
| false); |
| } |
| |
| void WebSafeBase64EscapeWithPadding(const string& src, string* dest) { |
| WebSafeBase64Escape(reinterpret_cast<const unsigned char*>(src.data()), src.size(), dest, true); |
| } |
| |
| // Returns true iff c is in the Base 32 alphabet. |
| bool ValidBase32Byte(char c) { |
| return (c >= 'A' && c <= 'Z') || (c >= '2' && c <= '7') || c == '='; |
| } |
| |
| // Mapping from number of Base32 escaped characters (0 through 8) to number of |
| // unescaped bytes. 8 Base32 escaped characters represent 5 unescaped bytes. |
| // For N < 8, then number of unescaped bytes is less than 5. Note that in |
| // valid input, N can only be 0, 2, 4, 5, 7, or 8 (corresponding to 0, 1, 2, |
| // 3, 4, or 5 unescaped bytes). |
| // |
| // We use 5 for invalid values of N to be safe, since this is used to compute |
| // the length of the buffer to hold unescaped data. |
| // |
| // See http://tools.ietf.org/html/rfc4648#section-6 for details. |
| static const int kBase32NumUnescapedBytes[] = {0, 5, 1, 5, 2, 3, 5, 4, 5}; |
| |
| int Base32Unescape(const char* src, int slen, char* dest, int szdest) { |
| int destidx = 0; |
| char escaped_bytes[8]; |
| unsigned char unescaped_bytes[5]; |
| while (slen > 0) { |
| // Collect the next 8 escaped bytes and convert to upper case. If there |
| // are less than 8 bytes left, pad with '=', but keep track of the number |
| // of non-padded bytes for later. |
| int non_padded_len = 8; |
| for (int i = 0; i < 8; ++i) { |
| escaped_bytes[i] = (i < slen) ? ascii_toupper(src[i]) : '='; |
| if (!ValidBase32Byte(escaped_bytes[i])) { |
| return -1; |
| } |
| // Stop counting escaped bytes at first '='. |
| if (escaped_bytes[i] == '=' && non_padded_len == 8) { |
| non_padded_len = i; |
| } |
| } |
| |
| // Convert the 8 escaped bytes to 5 unescaped bytes and copy to dest. |
| EightBase32DigitsToFiveBytes(escaped_bytes, unescaped_bytes); |
| const int num_unescaped = kBase32NumUnescapedBytes[non_padded_len]; |
| for (int i = 0; i < num_unescaped; ++i) { |
| if (destidx == szdest) { |
| // No more room in dest, so terminate early. |
| return -1; |
| } |
| dest[destidx] = unescaped_bytes[i]; |
| ++destidx; |
| } |
| src += 8; |
| slen -= 8; |
| } |
| return destidx; |
| } |
| |
| bool Base32Unescape(const char* src, int slen, string* dest) { |
| // Determine the size of the output string. |
| const int dest_len = 5 * (slen / 8) + kBase32NumUnescapedBytes[slen % 8]; |
| |
| dest->clear(); |
| 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 = Base32Unescape(src, slen, string_as_array(dest), dest->size()); |
| if (len < 0) { |
| dest->clear(); |
| return false; |
| } |
| |
| // Could be shorter if there was padding. |
| DCHECK_LE(len, dest_len); |
| dest->resize(len); |
| |
| return true; |
| } |
| |
| void GeneralFiveBytesToEightBase32Digits(const unsigned char* in_bytes, char* out, |
| const char* alphabet) { |
| // It's easier to just hard code this. |
| // The conversion isbased on the following picture of the division of a |
| // 40-bit block into 8 5-byte words: |
| // |
| // 5 3 2 5 1 4 4 1 5 2 3 5 |
| // |:::::::|:::::::|:::::::|:::::::|::::::: |
| // +----+----+----+----+----+----+----+---- |
| // |
| out[0] = alphabet[in_bytes[0] >> 3]; |
| out[1] = alphabet[(in_bytes[0] & 0x07) << 2 | in_bytes[1] >> 6]; |
| out[2] = alphabet[(in_bytes[1] & 0x3E) >> 1]; |
| out[3] = alphabet[(in_bytes[1] & 0x01) << 4 | in_bytes[2] >> 4]; |
| out[4] = alphabet[(in_bytes[2] & 0x0F) << 1 | in_bytes[3] >> 7]; |
| out[5] = alphabet[(in_bytes[3] & 0x7C) >> 2]; |
| out[6] = alphabet[(in_bytes[3] & 0x03) << 3 | in_bytes[4] >> 5]; |
| out[7] = alphabet[(in_bytes[4] & 0x1F)]; |
| } |
| |
| static int GeneralBase32Escape(const unsigned char* src, size_t szsrc, char* dest, size_t szdest, |
| const char* alphabet) { |
| static const char kPad32 = '='; |
| |
| if (szsrc == 0) return 0; |
| |
| char* cur_dest = dest; |
| const unsigned char* cur_src = src; |
| |
| // Five bytes of data encodes to eight characters of cyphertext. |
| // So we can pump through three-byte chunks atomically. |
| while (szsrc > 4) { // keep going until we have less than 40 bits |
| if (szdest < 8) return 0; |
| szdest -= 8; |
| |
| GeneralFiveBytesToEightBase32Digits(cur_src, cur_dest, alphabet); |
| |
| cur_dest += 8; |
| cur_src += 5; |
| szsrc -= 5; |
| } |
| |
| // Now deal with the tail (<=4 bytes). |
| if (szsrc > 0) { |
| if (szdest < 8) return 0; |
| szdest -= 8; |
| unsigned char last_chunk[5]; |
| memcpy(last_chunk, cur_src, szsrc); |
| |
| for (size_t i = szsrc; i < 5; ++i) { |
| last_chunk[i] = '\0'; |
| } |
| |
| GeneralFiveBytesToEightBase32Digits(last_chunk, cur_dest, alphabet); |
| int filled = (szsrc * 8) / 5 + 1; |
| cur_dest += filled; |
| |
| // Add on the padding. |
| for (int i = 0; i < (8 - filled); ++i) { |
| *(cur_dest++) = kPad32; |
| } |
| } |
| |
| return cur_dest - dest; |
| } |
| |
| static bool GeneralBase32Escape(const string& src, string* dest, const char* alphabet) { |
| const int max_escaped_size = CalculateBase32EscapedLen(src.length()); |
| dest->clear(); |
| dest->resize(max_escaped_size + 1, '\0'); |
| const int escaped_len = |
| GeneralBase32Escape(reinterpret_cast<const unsigned char*>(src.c_str()), src.length(), |
| &*dest->begin(), dest->size(), alphabet); |
| |
| DCHECK_LE(max_escaped_size, escaped_len); |
| |
| if (escaped_len < 0) { |
| dest->clear(); |
| return false; |
| } |
| |
| dest->resize(escaped_len); |
| return true; |
| } |
| |
| static const char Base32Alphabet[] = {'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', |
| 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', |
| 'W', 'X', 'Y', 'Z', '2', '3', '4', '5', '6', '7'}; |
| |
| int Base32Escape(const unsigned char* src, size_t szsrc, char* dest, size_t szdest) { |
| return GeneralBase32Escape(src, szsrc, dest, szdest, Base32Alphabet); |
| } |
| |
| bool Base32Escape(const string& src, string* dest) { |
| return GeneralBase32Escape(src, dest, Base32Alphabet); |
| } |
| |
| void FiveBytesToEightBase32Digits(const unsigned char* in_bytes, char* out) { |
| GeneralFiveBytesToEightBase32Digits(in_bytes, out, Base32Alphabet); |
| } |
| |
| static const char Base32HexAlphabet[] = { |
| '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F', |
| 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', |
| }; |
| |
| int Base32HexEscape(const unsigned char* src, size_t szsrc, char* dest, size_t szdest) { |
| return GeneralBase32Escape(src, szsrc, dest, szdest, Base32HexAlphabet); |
| } |
| |
| bool Base32HexEscape(const string& src, string* dest) { |
| return GeneralBase32Escape(src, dest, Base32HexAlphabet); |
| } |
| |
| int CalculateBase32EscapedLen(size_t input_len) { |
| DCHECK_LE(input_len, numeric_limits<size_t>::max() / 8); |
| size_t intermediate_result = 8 * input_len + 4; |
| size_t len = intermediate_result / 5; |
| len = (len + 7) & ~7; |
| return len; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // EightBase32DigitsToTenHexDigits() |
| // Converts an 8-digit base32 string to a 10-digit hex string. |
| // |
| // *in must point to 8 base32 digits. |
| // *out must point to 10 bytes. |
| // |
| // Base32 uses A-Z,2-7 to represent the numbers 0-31. |
| // See RFC3548 at http://www.ietf.org/rfc/rfc3548.txt |
| // for details on base32. |
| // ---------------------------------------------------------------------- |
| |
| void EightBase32DigitsToTenHexDigits(const char* in, char* out) { |
| unsigned char bytes[5]; |
| EightBase32DigitsToFiveBytes(in, bytes); |
| b2a_hex(bytes, out, 5); |
| } |
| |
| void EightBase32DigitsToFiveBytes(const char* in, unsigned char* bytes_out) { |
| static const char Base32InverseAlphabet[] = { |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 26 /*2*/, 27 /*3*/, 28 /*4*/, 29 /*5*/, 30 /*6*/, 31 /*7*/, |
| 99, 99, 99, 99, 99, 00 /*=*/, 99, 99, |
| 99, 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*/, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99, |
| 99, 99, 99, 99, 99, 99, 99, 99}; |
| |
| // Convert to raw bytes. It's easier to just hard code this. |
| bytes_out[0] = Base32InverseAlphabet[in[0]] << 3 | Base32InverseAlphabet[in[1]] >> 2; |
| |
| bytes_out[1] = Base32InverseAlphabet[in[1]] << 6 | Base32InverseAlphabet[in[2]] << 1 | |
| Base32InverseAlphabet[in[3]] >> 4; |
| |
| bytes_out[2] = Base32InverseAlphabet[in[3]] << 4 | Base32InverseAlphabet[in[4]] >> 1; |
| |
| bytes_out[3] = Base32InverseAlphabet[in[4]] << 7 | Base32InverseAlphabet[in[5]] << 2 | |
| Base32InverseAlphabet[in[6]] >> 3; |
| |
| bytes_out[4] = Base32InverseAlphabet[in[6]] << 5 | Base32InverseAlphabet[in[7]]; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // TenHexDigitsToEightBase32Digits() |
| // Converts a 10-digit hex string to an 8-digit base32 string. |
| // |
| // *in must point to 10 hex digits. |
| // *out must point to 8 bytes. |
| // |
| // See RFC3548 at http://www.ietf.org/rfc/rfc3548.txt |
| // for details on base32. |
| // ---------------------------------------------------------------------- |
| void TenHexDigitsToEightBase32Digits(const char* in, char* out) { |
| unsigned char bytes[5]; |
| |
| // Convert hex to raw bytes. |
| a2b_hex(in, bytes, 5); |
| FiveBytesToEightBase32Digits(bytes, out); |
| } |
| |
| // ---------------------------------------------------------------------- |
| // EscapeFileName / UnescapeFileName |
| // ---------------------------------------------------------------------- |
| static const Charmap escape_file_name_exceptions( |
| "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" // letters |
| "0123456789" // digits |
| "-_."); |
| |
| void EscapeFileName(const StringPiece& src, string* dst) { |
| // Reserve at least src.size() chars |
| dst->reserve(dst->size() + src.size()); |
| |
| for (char c : src) { |
| // We do not use "isalpha" because we want the behavior to be |
| // independent of the current locale settings. |
| if (escape_file_name_exceptions.contains(c)) { |
| dst->push_back(c); |
| |
| } else if (c == '/') { |
| dst->push_back('~'); |
| |
| } else { |
| char tmp[2]; |
| b2a_hex(reinterpret_cast<const unsigned char*>(&c), tmp, 1); |
| dst->push_back('%'); |
| dst->append(tmp, 2); |
| } |
| } |
| } |
| |
| void UnescapeFileName(const StringPiece& src_piece, string* dst) { |
| const char* src = src_piece.data(); |
| const int len = src_piece.size(); |
| for (int i = 0; i < len; ++i) { |
| const char c = src[i]; |
| if (c == '~') { |
| dst->push_back('/'); |
| |
| } else if ((c == '%') && (i + 2 < len)) { |
| unsigned char tmp[1]; |
| a2b_hex(src + i + 1, &tmp[0], 1); |
| dst->push_back(tmp[0]); |
| i += 2; |
| |
| } else { |
| dst->push_back(c); |
| } |
| } |
| } |
| |
| static char hex_value[256] = { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 0, 0, 0, // '0'..'9' |
| 0, 10, 11, 12, 13, 14, 15, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 'A'..'F' |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 10, 11, 12, 13, 14, 15, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, // 'a'..'f' |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}; |
| |
| static char hex_char[] = "0123456789abcdef"; |
| |
| // This is a templated function so that T can be either a char* |
| // or a string. This works because we use the [] operator to access |
| // individual characters at a time. |
| template <typename T> |
| void a2b_hex_t(const char* a, T b, int num) { |
| for (int i = 0; i < num; i++) { |
| b[i] = (hex_value[a[i * 2] & 0xFF] << 4) + (hex_value[a[i * 2 + 1] & 0xFF]); |
| } |
| } |
| |
| string a2b_bin(const string& a, bool byte_order_msb) { |
| string result; |
| const char* data = a.c_str(); |
| int num_bytes = (a.size() + 7) / 8; |
| for (int byte_offset = 0; byte_offset < num_bytes; ++byte_offset) { |
| unsigned char c = 0; |
| for (int bit_offset = 0; bit_offset < 8; ++bit_offset) { |
| if (*data == '\0') break; |
| if (*data++ != '0') { |
| int bits_to_shift = (byte_order_msb) ? 7 - bit_offset : bit_offset; |
| c |= (1 << bits_to_shift); |
| } |
| } |
| result.append(1, c); |
| } |
| return result; |
| } |
| |
| // This is a templated function so that T can be either a char* |
| // or a string. This works because we use the [] operator to access |
| // individual characters at a time. |
| template <typename T> |
| void b2a_hex_t(const unsigned char* b, T a, int num) { |
| for (int i = 0; i < num; i++) { |
| a[i * 2 + 0] = hex_char[b[i] >> 4]; |
| a[i * 2 + 1] = hex_char[b[i] & 0xf]; |
| } |
| } |
| |
| string b2a_bin(const string& b, bool byte_order_msb) { |
| string result; |
| for (char c : b) { |
| for (int bit_offset = 0; bit_offset < 8; ++bit_offset) { |
| int x = (byte_order_msb) ? 7 - bit_offset : bit_offset; |
| result.append(1, (c & (1 << x)) ? '1' : '0'); |
| } |
| } |
| return result; |
| } |
| |
| void b2a_hex(const unsigned char* b, char* a, int num) { |
| b2a_hex_t<char*>(b, a, num); |
| } |
| |
| void a2b_hex(const char* a, unsigned char* b, int num) { |
| a2b_hex_t<unsigned char*>(a, b, num); |
| } |
| |
| void a2b_hex(const char* a, char* b, int num) { |
| a2b_hex_t<char*>(a, b, num); |
| } |
| |
| string b2a_hex(const char* b, int len) { |
| string result; |
| result.resize(len << 1); |
| b2a_hex_t<string&>(reinterpret_cast<const unsigned char*>(b), result, len); |
| return result; |
| } |
| |
| string b2a_hex(const StringPiece& b) { |
| return b2a_hex(b.data(), b.size()); |
| } |
| |
| string a2b_hex(const string& a) { |
| string result; |
| a2b_hex(a.c_str(), &result, a.size() / 2); |
| |
| return result; |
| } |
| |
| void b2a_hex(const unsigned char* from, string* to, int num) { |
| to->resize(num << 1); |
| b2a_hex_t<string&>(from, *to, num); |
| } |
| |
| void a2b_hex(const char* from, string* to, int num) { |
| to->resize(num); |
| a2b_hex_t<string&>(from, *to, num); |
| } |
| |
| const char* kDontNeedShellEscapeChars = |
| "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_.=/:,@"; |
| |
| string ShellEscape(StringPiece src) { |
| if (!src.empty() && // empty string needs quotes |
| src.find_first_not_of(kDontNeedShellEscapeChars) == StringPiece::npos) { |
| // only contains chars that don't need quotes; it's fine |
| return src.ToString(); |
| } else if (src.find('\'') == StringPiece::npos) { |
| // no single quotes; just wrap it in single quotes |
| return StrCat("'", src, "'"); |
| } else { |
| // needs double quote escaping |
| string result = "\""; |
| for (char c : src) { |
| switch (c) { |
| case '\\': |
| case '$': |
| case '"': |
| case '`': |
| result.push_back('\\'); |
| }; |
| result.push_back(c); |
| } |
| result.push_back('"'); |
| return result; |
| } |
| } |
| |
| static const char kHexTable[513] = |
| "000102030405060708090a0b0c0d0e0f" |
| "101112131415161718191a1b1c1d1e1f" |
| "202122232425262728292a2b2c2d2e2f" |
| "303132333435363738393a3b3c3d3e3f" |
| "404142434445464748494a4b4c4d4e4f" |
| "505152535455565758595a5b5c5d5e5f" |
| "606162636465666768696a6b6c6d6e6f" |
| "707172737475767778797a7b7c7d7e7f" |
| "808182838485868788898a8b8c8d8e8f" |
| "909192939495969798999a9b9c9d9e9f" |
| "a0a1a2a3a4a5a6a7a8a9aaabacadaeaf" |
| "b0b1b2b3b4b5b6b7b8b9babbbcbdbebf" |
| "c0c1c2c3c4c5c6c7c8c9cacbcccdcecf" |
| "d0d1d2d3d4d5d6d7d8d9dadbdcdddedf" |
| "e0e1e2e3e4e5e6e7e8e9eaebecedeeef" |
| "f0f1f2f3f4f5f6f7f8f9fafbfcfdfeff"; |
| |
| //------------------------------------------------------------------------ |
| // ByteStringToAscii |
| // Reads at most bytes_to_read from binary_string and prints it to |
| // ascii_string in downcased hex. |
| //------------------------------------------------------------------------ |
| void ByteStringToAscii(string const& binary_string, int bytes_to_read, string* ascii_string) { |
| if (binary_string.size() < bytes_to_read) { |
| bytes_to_read = binary_string.size(); |
| } |
| |
| CHECK_GE(bytes_to_read, 0); |
| ascii_string->resize(bytes_to_read * 2); |
| |
| string::const_iterator in = binary_string.begin(); |
| string::iterator out = ascii_string->begin(); |
| |
| for (int i = 0; i < bytes_to_read; i++) { |
| *out++ = kHexTable[(*in) * 2]; |
| *out++ = kHexTable[(*in) * 2 + 1]; |
| ++in; |
| } |
| } |
| |
| //------------------------------------------------------------------------ |
| // ByteStringFromAscii |
| // Converts the hex from ascii_string into binary data and |
| // writes the binary data into binary_string. |
| // Empty input successfully converts to empty output. |
| // Returns false and may modify output if it is |
| // unable to parse the hex string. |
| //------------------------------------------------------------------------ |
| bool ByteStringFromAscii(string const& hex_string, string* binary_string) { |
| binary_string->clear(); |
| |
| if ((hex_string.size() % 2) != 0) { |
| return false; |
| } |
| |
| int value = 0; |
| for (int i = 0; i < hex_string.size(); i++) { |
| char c = hex_string[i]; |
| |
| if (!ascii_isxdigit(c)) { |
| return false; |
| } |
| |
| if (ascii_isdigit(c)) { |
| value += c - '0'; |
| } else if (ascii_islower(c)) { |
| value += 10 + c - 'a'; |
| } else { |
| value += 10 + c - 'A'; |
| } |
| |
| if (i & 1) { |
| binary_string->push_back(value); |
| value = 0; |
| } else { |
| value <<= 4; |
| } |
| } |
| |
| return true; |
| } |
| |
| // ---------------------------------------------------------------------- |
| // CleanStringLineEndings() |
| // Clean up a multi-line string to conform to Unix line endings. |
| // Reads from src and appends to dst, so usually dst should be empty. |
| // |
| // If there is no line ending at the end of a non-empty string, it can |
| // be added automatically. |
| // |
| // Four different types of input are correctly handled: |
| // |
| // - Unix/Linux files: line ending is LF, pass through unchanged |
| // |
| // - DOS/Windows files: line ending is CRLF: convert to LF |
| // |
| // - Legacy Mac files: line ending is CR: convert to LF |
| // |
| // - Garbled files: random line endings, covert gracefully |
| // lonely CR, lonely LF, CRLF: convert to LF |
| // |
| // @param src The multi-line string to convert |
| // @param dst The converted string is appended to this string |
| // @param auto_end_last_line Automatically terminate the last line |
| // |
| // Limitations: |
| // |
| // This does not do the right thing for CRCRLF files created by |
| // broken programs that do another Unix->DOS conversion on files |
| // that are already in CRLF format. For this, a two-pass approach |
| // brute-force would be needed that |
| // |
| // (1) determines the presence of LF (first one is ok) |
| // (2) if yes, removes any CR, else convert every CR to LF |
| |
| void CleanStringLineEndings(const string& src, string* dst, bool auto_end_last_line) { |
| if (dst->empty()) { |
| dst->append(src); |
| CleanStringLineEndings(dst, auto_end_last_line); |
| } else { |
| string tmp = src; |
| CleanStringLineEndings(&tmp, auto_end_last_line); |
| dst->append(tmp); |
| } |
| } |
| |
| void CleanStringLineEndings(string* str, bool auto_end_last_line) { |
| int output_pos = 0; |
| bool r_seen = false; |
| int len = str->size(); |
| |
| char* p = string_as_array(str); |
| |
| for (int input_pos = 0; input_pos < len;) { |
| if (!r_seen && input_pos + 8 < len) { |
| uint64 v = UNALIGNED_LOAD64(p + input_pos); |
| // Loop over groups of 8 bytes at a time until we come across |
| // a word that has a byte whose value is less than or equal to |
| // '\r' (i.e. could contain a \n (0x0a) or a \r (0x0d) ). |
| // |
| // We use a has_less macro that quickly tests a whole 64-bit |
| // word to see if any of the bytes has a value < N. |
| // |
| // For more details, see: |
| // http://graphics.stanford.edu/~seander/bithacks.html#HasLessInWord |
| #define has_less(x, n) (((x) - ~0ULL / 255 * (n)) & ~(x) & ~0ULL / 255 * 128) |
| if (!has_less(v, '\r' + 1)) { |
| #undef has_less |
| // No byte in this word has a value that could be a \r or a \n |
| if (output_pos != input_pos) UNALIGNED_STORE64(p + output_pos, v); |
| input_pos += 8; |
| output_pos += 8; |
| continue; |
| } |
| } |
| string::const_reference in = p[input_pos]; |
| if (in == '\r') { |
| if (r_seen) p[output_pos++] = '\n'; |
| r_seen = true; |
| } else if (in == '\n') { |
| if (input_pos != output_pos) |
| p[output_pos++] = '\n'; |
| else |
| output_pos++; |
| r_seen = false; |
| } else { |
| if (r_seen) p[output_pos++] = '\n'; |
| r_seen = false; |
| if (input_pos != output_pos) |
| p[output_pos++] = in; |
| else |
| output_pos++; |
| } |
| input_pos++; |
| } |
| if (r_seen || (auto_end_last_line && output_pos > 0 && p[output_pos - 1] != '\n')) { |
| str->resize(output_pos + 1); |
| str->operator[](output_pos) = '\n'; |
| } else if (output_pos < len) { |
| str->resize(output_pos); |
| } |
| } |
| |
| } // namespace strings |
