| /* |
| * Copyright 2007 Google Inc. All rights reserved. |
| * Copyright 2012 Apple Inc. All rights reserved. |
| * |
| * 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 Inc. 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. |
| */ |
| |
| #include "config.h" |
| #include "URLCanonInternal.h" |
| |
| #include <cstdio> |
| #include <errno.h> |
| #include <stdlib.h> |
| #include <string> |
| |
| #if USE(WTFURL) |
| |
| namespace WTF { |
| |
| namespace URLCanonicalizer { |
| |
| namespace { |
| |
| template<typename CharacterType, typename UCHAR> |
| void doAppendStringOfType(const CharacterType* source, int length, URLCharacterTypes::CharacterTypes type, URLBuffer<char>& output) |
| { |
| for (int i = 0; i < length; ++i) { |
| if (static_cast<UCHAR>(source[i]) >= 0x80) { |
| // ReadChar will fill the code point with kUnicodeReplacementCharacter |
| // when the input is invalid, which is what we want. |
| unsigned codePoint; |
| readUTFChar(source, &i, length, &codePoint); |
| AppendUTF8EscapedValue(codePoint, output); |
| } else { |
| // Just append the 7-bit character, possibly escaping it. |
| unsigned char uch = static_cast<unsigned char>(source[i]); |
| if (!URLCharacterTypes::isCharacterOfType(uch, type)) |
| appendURLEscapedCharacter(uch, output); |
| else |
| output.append(uch); |
| } |
| } |
| } |
| |
| // This function assumes the input values are all contained in 8-bit, |
| // although it allows any type. Returns true if input is valid, false if not. |
| template<typename CharacterType, typename UCHAR> |
| void doAppendInvalidNarrowString(const CharacterType* spec, int begin, int end, URLBuffer<char>& output) |
| { |
| for (int i = begin; i < end; ++i) { |
| UCHAR uch = static_cast<UCHAR>(spec[i]); |
| if (uch >= 0x80) { |
| // Handle UTF-8/16 encodings. This call will correctly handle the error |
| // case by appending the invalid character. |
| AppendUTF8EscapedChar(spec, &i, end, output); |
| } else if (uch <= ' ' || uch == 0x7f) { |
| // This function is for error handling, so we escape all control |
| // characters and spaces, but not anything else since we lack |
| // context to do something more specific. |
| appendURLEscapedCharacter(static_cast<unsigned char>(uch), output); |
| } else |
| output.append(static_cast<char>(uch)); |
| } |
| } |
| |
| // Overrides one component, see the URLCanonicalizer::Replacements structure for |
| // what the various combionations of source pointer and component mean. |
| void doOverrideComponent(const char* overrideSource, const URLComponent& overrideComponent, const char*& destination, URLComponent& destinationComponent) |
| { |
| if (overrideSource) { |
| destination = overrideSource; |
| destinationComponent = overrideComponent; |
| } |
| } |
| |
| // Similar to doOverrideComponent except that it takes a UTF-16 input and does |
| // not actually set the output character pointer. |
| // |
| // The input is converted to UTF-8 at the end of the given buffer as a temporary |
| // holding place. The component indentifying the portion of the buffer used in |
| // the |utf8Buffer| will be specified in |*destinationComponent|. |
| // |
| // This will not actually set any |dest| pointer like doOverrideComponent |
| // does because all of the pointers will point into the |utf8Buffer|, which |
| // may get resized while we're overriding a subsequent component. Instead, the |
| // caller should use the beginning of the |utf8Buffer| as the string pointer |
| // for all components once all overrides have been prepared. |
| bool PrepareUTF16OverrideComponent(const UChar* overrideSource, |
| const URLComponent& overrideComponent, |
| URLBuffer<char>& utf8Buffer, |
| URLComponent* destinationComponent) |
| { |
| bool success = true; |
| if (overrideSource) { |
| if (!overrideComponent.isValid()) { |
| // Non-"valid" component (means delete), so we need to preserve that. |
| *destinationComponent = URLComponent(); |
| } else { |
| // Convert to UTF-8. |
| destinationComponent->setBegin(utf8Buffer.length()); |
| success = ConvertUTF16ToUTF8(&overrideSource[overrideComponent.begin()], |
| overrideComponent.length(), utf8Buffer); |
| destinationComponent->setLength(utf8Buffer.length() - destinationComponent->begin()); |
| } |
| } |
| return success; |
| } |
| |
| } // namespace |
| |
| const char kCharToHexLookup[8] = { |
| 0, // 0x00 - 0x1f |
| '0', // 0x20 - 0x3f: digits 0 - 9 are 0x30 - 0x39 |
| 'A' - 10, // 0x40 - 0x5f: letters A - F are 0x41 - 0x46 |
| 'a' - 10, // 0x60 - 0x7f: letters a - f are 0x61 - 0x66 |
| 0, // 0x80 - 0x9F |
| 0, // 0xA0 - 0xBF |
| 0, // 0xC0 - 0xDF |
| 0, // 0xE0 - 0xFF |
| }; |
| |
| const UChar kUnicodeReplacementCharacter = 0xfffd; |
| |
| void appendStringOfType(const char* source, int length, URLCharacterTypes::CharacterTypes urlComponentType, URLBuffer<char>& output) |
| { |
| doAppendStringOfType<char, unsigned char>(source, length, urlComponentType, output); |
| } |
| |
| void appendStringOfType(const UChar* source, int length, URLCharacterTypes::CharacterTypes urlComponentType, URLBuffer<char>& output) |
| { |
| doAppendStringOfType<UChar, UChar>(source, length, urlComponentType, output); |
| } |
| |
| void AppendInvalidNarrowString(const char* spec, int begin, int end, URLBuffer<char>& output) |
| { |
| doAppendInvalidNarrowString<char, unsigned char>(spec, begin, end, output); |
| } |
| |
| void AppendInvalidNarrowString(const UChar* spec, int begin, int end, URLBuffer<char>& output) |
| { |
| doAppendInvalidNarrowString<UChar, UChar>(spec, begin, end, output); |
| } |
| |
| bool ConvertUTF16ToUTF8(const UChar* input, int inputLength, URLBuffer<char>& output) |
| { |
| bool success = true; |
| for (int i = 0; i < inputLength; ++i) { |
| unsigned codePoint; |
| success &= readUTFChar(input, &i, inputLength, &codePoint); |
| AppendUTF8Value(codePoint, output); |
| } |
| return success; |
| } |
| |
| bool ConvertUTF8ToUTF16(const char* input, int inputLength, URLBuffer<UChar>& output) |
| { |
| bool success = true; |
| for (int i = 0; i < inputLength; i++) { |
| unsigned codePoint; |
| success &= readUTFChar(input, &i, inputLength, &codePoint); |
| AppendUTF16Value(codePoint, output); |
| } |
| return success; |
| } |
| |
| void SetupOverrideComponents(const char* /* base */, |
| const Replacements<char>& repl, |
| URLComponentSource<char>* source, |
| URLSegments* parsed) |
| { |
| // Get the source and parsed structures of the things we are replacing. |
| const URLComponentSource<char>& replSource = repl.sources(); |
| const URLSegments& replParsed = repl.components(); |
| |
| doOverrideComponent(replSource.scheme, replParsed.scheme, source->scheme, parsed->scheme); |
| doOverrideComponent(replSource.username, replParsed.username, source->username, parsed->username); |
| doOverrideComponent(replSource.password, replParsed.password, source->password, parsed->password); |
| |
| // Our host should be empty if not present, so override the default setup. |
| doOverrideComponent(replSource.host, replParsed.host, source->host, parsed->host); |
| if (parsed->host.length() == -1) |
| parsed->host.setLength(0); |
| |
| doOverrideComponent(replSource.port, replParsed.port, source->port, parsed->port); |
| doOverrideComponent(replSource.path, replParsed.path, source->path, parsed->path); |
| doOverrideComponent(replSource.query, replParsed.query, source->query, parsed->query); |
| doOverrideComponent(replSource.ref, replParsed.fragment, source->ref, parsed->fragment); |
| } |
| |
| bool SetupUTF16OverrideComponents(const char* /* base */, |
| const Replacements<UChar>& repl, |
| URLBuffer<char>& utf8Buffer, |
| URLComponentSource<char>* source, |
| URLSegments* parsed) |
| { |
| bool success = true; |
| |
| // Get the source and parsed structures of the things we are replacing. |
| const URLComponentSource<UChar>& replSource = repl.sources(); |
| const URLSegments& replParsed = repl.components(); |
| |
| success &= PrepareUTF16OverrideComponent(replSource.scheme, replParsed.scheme, |
| utf8Buffer, &parsed->scheme); |
| success &= PrepareUTF16OverrideComponent(replSource.username, replParsed.username, |
| utf8Buffer, &parsed->username); |
| success &= PrepareUTF16OverrideComponent(replSource.password, replParsed.password, |
| utf8Buffer, &parsed->password); |
| success &= PrepareUTF16OverrideComponent(replSource.host, replParsed.host, |
| utf8Buffer, &parsed->host); |
| success &= PrepareUTF16OverrideComponent(replSource.port, replParsed.port, |
| utf8Buffer, &parsed->port); |
| success &= PrepareUTF16OverrideComponent(replSource.path, replParsed.path, |
| utf8Buffer, &parsed->path); |
| success &= PrepareUTF16OverrideComponent(replSource.query, replParsed.query, |
| utf8Buffer, &parsed->query); |
| success &= PrepareUTF16OverrideComponent(replSource.ref, replParsed.fragment, |
| utf8Buffer, &parsed->fragment); |
| |
| // PrepareUTF16OverrideComponent will not have set the data pointer since the |
| // buffer could be resized, invalidating the pointers. We set the data |
| // pointers for affected components now that the buffer is finalized. |
| if (replSource.scheme) |
| source->scheme = utf8Buffer.data(); |
| if (replSource.username) |
| source->username = utf8Buffer.data(); |
| if (replSource.password) |
| source->password = utf8Buffer.data(); |
| if (replSource.host) |
| source->host = utf8Buffer.data(); |
| if (replSource.port) |
| source->port = utf8Buffer.data(); |
| if (replSource.path) |
| source->path = utf8Buffer.data(); |
| if (replSource.query) |
| source->query = utf8Buffer.data(); |
| if (replSource.ref) |
| source->ref = utf8Buffer.data(); |
| |
| return success; |
| } |
| |
| #if !OS(WINDOWS) |
| int _itoa_s(int value, char* buffer, size_t sizeInChars, int radix) |
| { |
| int written; |
| if (radix == 10) |
| written = snprintf(buffer, sizeInChars, "%d", value); |
| else if (radix == 16) |
| written = snprintf(buffer, sizeInChars, "%x", value); |
| else |
| return EINVAL; |
| |
| if (static_cast<size_t>(written) >= sizeInChars) { |
| // Output was truncated, or written was negative. |
| return EINVAL; |
| } |
| return 0; |
| } |
| |
| int _itow_s(int value, UChar* buffer, size_t sizeInChars, int radix) |
| { |
| if (radix != 10) |
| return EINVAL; |
| |
| // No more than 12 characters will be required for a 32-bit integer. |
| // Add an extra byte for the terminating null. |
| char temp[13]; |
| int written = snprintf(temp, sizeof(temp), "%d", value); |
| if (static_cast<size_t>(written) >= sizeInChars) { |
| // Output was truncated, or written was negative. |
| return EINVAL; |
| } |
| |
| for (int i = 0; i < written; ++i) |
| buffer[i] = static_cast<UChar>(temp[i]); |
| buffer[written] = '\0'; |
| return 0; |
| } |
| |
| #endif // !OS(WINDOWS) |
| |
| } // namespace URLCanonicalizer |
| |
| } // namespace WTF |
| |
| #endif // USE(WTFURL) |
