Integrate most of GoogleURL in WTFURL
[WebKit-https.git] / Source / WTF / wtf / url / src / URLCanonInternal.h
1 /*
2  * Copyright 2011 Google Inc. All rights reserved.
3  * Copyright 2012 Apple Inc. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions are
7  * met:
8  *
9  *     * Redistributions of source code must retain the above copyright
10  * notice, this list of conditions and the following disclaimer.
11  *     * Redistributions in binary form must reproduce the above
12  * copyright notice, this list of conditions and the following disclaimer
13  * in the documentation and/or other materials provided with the
14  * distribution.
15  *     * Neither the name of Google Inc. nor the names of its
16  * contributors may be used to endorse or promote products derived from
17  * this software without specific prior written permission.
18  *
19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
20  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
21  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
22  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30  */
31
32 // This file is intended to be included in another C++ file where the character
33 // types are defined. This allows us to write mostly generic code, but not have
34 // templace bloat because everything is inlined when anybody calls any of our
35 // functions.
36
37 #ifndef URLCanonInternal_h
38 #define URLCanonInternal_h
39
40 #include "URLCanon.h"
41 #include "URLCharacterTypes.h"
42 #include <stdlib.h>
43 #include <wtf/HexNumber.h>
44
45 #if USE(WTFURL)
46
47 namespace WTF {
48
49 namespace URLCanonicalizer {
50
51 // Appends the given string to the output, escaping characters that do not
52 // match the given |type| in SharedCharTypes.
53 void appendStringOfType(const char* source, int length, URLCharacterTypes::CharacterTypes urlComponentType, URLBuffer<char>& output);
54 void appendStringOfType(const UChar* source, int length, URLCharacterTypes::CharacterTypes urlComponentType, URLBuffer<char>& output);
55
56 // This lookup table allows fast conversion between ASCII hex letters and their
57 // corresponding numerical value. The 8-bit range is divided up into 8
58 // regions of 0x20 characters each. Each of the three character types (numbers,
59 // uppercase, lowercase) falls into different regions of this range. The table
60 // contains the amount to subtract from characters in that range to get at
61 // the corresponding numerical value.
62 //
63 // See HexDigitToValue for the lookup.
64 extern const char kCharToHexLookup[8];
65
66 // Assumes the input is a valid hex digit! Call isHexChar before using this.
67 inline unsigned char hexCharToValue(unsigned char character)
68 {
69     return character - kCharToHexLookup[character / 0x20];
70 }
71
72 // Indicates if the given character is a dot or dot equivalent, returning the
73 // number of characters taken by it. This will be one for a literal dot, 3 for
74 // an escaped dot. If the character is not a dot, this will return 0.
75 template<typename CharacterType>
76 inline int isDot(const CharacterType* spec, int offset, int end)
77 {
78     if (spec[offset] == '.')
79         return 1;
80
81     if (spec[offset] == '%' && offset + 3 <= end && spec[offset + 1] == '2' && (spec[offset + 2] == 'e' || spec[offset + 2] == 'E')) {
82         // Found "%2e"
83         return 3;
84     }
85     return 0;
86 }
87
88 // Returns the canonicalized version of the input character according to scheme
89 // rules. This is implemented alongside the scheme canonicalizer, and is
90 // required for relative URL resolving to test for scheme equality.
91 //
92 // Returns 0 if the input character is not a valid scheme character.
93 char canonicalSchemeChar(UChar);
94
95 // Write a single character, escaped, to the output. This always escapes: it
96 // does no checking that thee character requires escaping.
97 // Escaping makes sense only 8 bit chars, so code works in all cases of
98 // input parameters (8/16bit).
99 template<typename InChar, typename OutChar>
100 inline void appendURLEscapedCharacter(InChar character, URLBuffer<OutChar>& buffer)
101 {
102     buffer.append('%');
103     buffer.append(WTF::Internal::upperHexDigits[character >> 4]);
104     buffer.append(WTF::Internal::upperHexDigits[character & 0xf]);
105 }
106
107 // The character we'll substitute for undecodable or invalid characters.
108 extern const UChar kUnicodeReplacementCharacter;
109
110 // UTF-8 functions ------------------------------------------------------------
111
112 // Reads one character in UTF-8 starting at |*begin| in |str| and places
113 // the decoded value into |*codePoint|. If the character is valid, we will
114 // return true. If invalid, we'll return false and put the
115 // kUnicodeReplacementCharacter into |*codePoint|.
116 //
117 // |*begin| will be updated to point to the last character consumed so it
118 // can be incremented in a loop and will be ready for the next character.
119 // (for a single-byte ASCII character, it will not be changed).
120 //
121 // Implementation is in URLCanonicalizer_icu.cc.
122 bool readUTFChar(const char* str, int* begin, int length, unsigned* codePointOut);
123
124 // Generic To-UTF-8 converter. This will call the given append method for each
125 // character that should be appended, with the given output method. Wrappers
126 // are provided below for escaped and non-escaped versions of this.
127 //
128 // The charactervalue must have already been checked that it's a valid Unicode
129 // character.
130 template<class Output, void appendFunction(unsigned char, Output&)>
131 inline void doAppendUTF8(unsigned charactervalue, Output& output)
132 {
133     if (charactervalue <= 0x7f) {
134         appendFunction(static_cast<unsigned char>(charactervalue), output);
135     } else if (charactervalue <= 0x7ff) {
136         // 110xxxxx 10xxxxxx
137         appendFunction(static_cast<unsigned char>(0xC0 | (charactervalue >> 6)), output);
138         appendFunction(static_cast<unsigned char>(0x80 | (charactervalue & 0x3f)), output);
139     } else if (charactervalue <= 0xffff) {
140         // 1110xxxx 10xxxxxx 10xxxxxx
141         appendFunction(static_cast<unsigned char>(0xe0 | (charactervalue >> 12)), output);
142         appendFunction(static_cast<unsigned char>(0x80 | ((charactervalue >> 6) & 0x3f)), output);
143         appendFunction(static_cast<unsigned char>(0x80 | (charactervalue & 0x3f)), output);
144     } else if (charactervalue <= 0x10FFFF) { // Max unicode code point.
145         // 11110xxx 10xxxxxx 10xxxxxx 10xxxxxx
146         appendFunction(static_cast<unsigned char>(0xf0 | (charactervalue >> 18)), output);
147         appendFunction(static_cast<unsigned char>(0x80 | ((charactervalue >> 12) & 0x3f)), output);
148         appendFunction(static_cast<unsigned char>(0x80 | ((charactervalue >> 6) & 0x3f)), output);
149         appendFunction(static_cast<unsigned char>(0x80 | (charactervalue & 0x3f)), output);
150     } else {
151         // Invalid UTF-8 character (>20 bits).
152         ASSERT_NOT_REACHED();
153     }
154 }
155
156 // Helper used by AppendUTF8Value below. We use an unsigned parameter so there
157 // are no funny sign problems with the input, but then have to convert it to
158 // a regular char for appending.
159 inline void AppendCharToOutput(unsigned char character, URLBuffer<char>& output)
160 {
161     output.append(static_cast<char>(character));
162 }
163
164 // Writes the given character to the output as UTF-8. This does NO checking
165 // of the validity of the unicode characters; the caller should ensure that
166 // the value it is appending is valid to append.
167 inline void AppendUTF8Value(unsigned charactervalue, URLBuffer<char>& output)
168 {
169     doAppendUTF8<URLBuffer<char>, AppendCharToOutput>(charactervalue, output);
170 }
171
172 // Writes the given character to the output as UTF-8, escaping ALL
173 // characters (even when they are ASCII). This does NO checking of the
174 // validity of the unicode characters; the caller should ensure that the value
175 // it is appending is valid to append.
176 inline void AppendUTF8EscapedValue(unsigned charactervalue, URLBuffer<char>& output)
177 {
178     doAppendUTF8<URLBuffer<char>, appendURLEscapedCharacter>(charactervalue, output);
179 }
180
181 // UTF-16 functions -----------------------------------------------------------
182
183 // Reads one character in UTF-16 starting at |*begin| in |str| and places
184 // the decoded value into |*codePoint|. If the character is valid, we will
185 // return true. If invalid, we'll return false and put the
186 // kUnicodeReplacementCharacter into |*codePoint|.
187 //
188 // |*begin| will be updated to point to the last character consumed so it
189 // can be incremented in a loop and will be ready for the next character.
190 // (for a single-16-bit-word character, it will not be changed).
191 //
192 // Implementation is in URLCanonicalizer_icu.cc.
193 bool readUTFChar(const UChar* str, int* begin, int length, unsigned* codePoint);
194
195 // Equivalent to U16_APPEND_UNSAFE in ICU but uses our output method.
196 inline void AppendUTF16Value(unsigned codePoint, URLBuffer<UChar>& output)
197 {
198     if (codePoint > 0xffff) {
199         output.append(static_cast<UChar>((codePoint >> 10) + 0xd7c0));
200         output.append(static_cast<UChar>((codePoint & 0x3ff) | 0xdc00));
201     } else
202         output.append(static_cast<UChar>(codePoint));
203 }
204
205 // Escaping functions ---------------------------------------------------------
206
207 // Writes the given character to the output as UTF-8, escaped. Call this
208 // function only when the input is wide. Returns true on success. Failure
209 // means there was some problem with the encoding, we'll still try to
210 // update the |*begin| pointer and add a placeholder character to the
211 // output so processing can continue.
212 //
213 // We will append the character starting at ch[begin] with the buffer ch
214 // being |length|. |*begin| will be updated to point to the last character
215 // consumed (we may consume more than one for UTF-16) so that if called in
216 // a loop, incrementing the pointer will move to the next character.
217 //
218 // Every single output character will be escaped. This means that if you
219 // give it an ASCII character as input, it will be escaped. Some code uses
220 // this when it knows that a character is invalid according to its rules
221 // for validity. If you don't want escaping for ASCII characters, you will
222 // have to filter them out prior to calling this function.
223 //
224 // Assumes that ch[begin] is within range in the array, but does not assume
225 // that any following characters are.
226 inline bool AppendUTF8EscapedChar(const UChar* str, int* begin, int length, URLBuffer<char>& output)
227 {
228     // UTF-16 input. ReadUChar will handle invalid characters for us and give
229     // us the kUnicodeReplacementCharacter, so we don't have to do special
230     // checking after failure, just pass through the failure to the caller.
231     unsigned charactervalue;
232     bool success = readUTFChar(str, begin, length, &charactervalue);
233     AppendUTF8EscapedValue(charactervalue, output);
234     return success;
235 }
236
237 // Handles UTF-8 input. See the wide version above for usage.
238 inline bool AppendUTF8EscapedChar(const char* str, int* begin, int length, URLBuffer<char>& output)
239 {
240     // ReadUTF8Char will handle invalid characters for us and give us the
241     // kUnicodeReplacementCharacter, so we don't have to do special checking
242     // after failure, just pass through the failure to the caller.
243     unsigned ch;
244     bool success = readUTFChar(str, begin, length, &ch);
245     AppendUTF8EscapedValue(ch, output);
246     return success;
247 }
248
249 // Given a '%' character at |*begin| in the string |spec|, this will decode
250 // the escaped value and put it into |*unescapedValue| on success (returns
251 // true). On failure, this will return false, and will not write into
252 // |*unescapedValue|.
253 //
254 // |*begin| will be updated to point to the last character of the escape
255 // sequence so that when called with the index of a for loop, the next time
256 // through it will point to the next character to be considered. On failure,
257 // |*begin| will be unchanged.
258 inline bool Is8BitChar(char)
259 {
260     return true; // this case is specialized to avoid a warning
261 }
262 inline bool Is8BitChar(UChar c)
263 {
264     return c <= 255;
265 }
266
267 template<typename CHAR>
268 inline bool DecodeEscaped(const CHAR* spec, int* begin, int end, unsigned char* unescapedValue)
269 {
270     if (*begin + 3 > end || !Is8BitChar(spec[*begin + 1]) || !Is8BitChar(spec[*begin + 2])) {
271         // Invalid escape sequence because there's not enough room, or the
272         // digits are not ASCII.
273         return false;
274     }
275
276     unsigned char first = static_cast<unsigned char>(spec[*begin + 1]);
277     unsigned char second = static_cast<unsigned char>(spec[*begin + 2]);
278     if (!URLCharacterTypes::isHexChar(first) || !URLCharacterTypes::isHexChar(second)) {
279         // Invalid hex digits, fail.
280         return false;
281     }
282
283     // Valid escape sequence.
284     *unescapedValue = (hexCharToValue(first) << 4) + hexCharToValue(second);
285     *begin += 2;
286     return true;
287 }
288
289 // Appends the given substring to the output, escaping "some" characters that
290 // it feels may not be safe. It assumes the input values are all contained in
291 // 8-bit although it allows any type.
292 //
293 // This is used in error cases to append invalid output so that it looks
294 // approximately correct. Non-error cases should not call this function since
295 // the escaping rules are not guaranteed!
296 void AppendInvalidNarrowString(const char* spec, int begin, int end, URLBuffer<char>& output);
297 void AppendInvalidNarrowString(const UChar* spec, int begin, int end, URLBuffer<char>& output);
298
299 // Misc canonicalization helpers ----------------------------------------------
300
301 // Converts between UTF-8 and UTF-16, returning true on successful conversion.
302 // The output will be appended to the given canonicalizer output (so make sure
303 // it's empty if you want to replace).
304 //
305 // On invalid input, this will still write as much output as possible,
306 // replacing the invalid characters with the "invalid character". It will
307 // return false in the failure case, and the caller should not continue as
308 // normal.
309 bool ConvertUTF16ToUTF8(const UChar* input, int inputLength, URLBuffer<char>& output);
310 bool ConvertUTF8ToUTF16(const char* input, int inputLength, URLBuffer<UChar>& output);
311
312 // Converts from UTF-16 to 8-bit using the character set converter. If the
313 // converter is null, this will use UTF-8.
314 void ConvertUTF16ToQueryEncoding(const UChar* input, const URLComponent& query, CharsetConverter*, URLBuffer<char>& output);
315
316 // Applies the replacements to the given component source. The component source
317 // should be pre-initialized to the "old" base. That is, all pointers will
318 // point to the spec of the old URL, and all of the Parsed components will
319 // be indices into that string.
320 //
321 // The pointers and components in the |source| for all non-null strings in the
322 // |repl| (replacements) will be updated to reference those strings.
323 // Canonicalizing with the new |source| and |parsed| can then combine URL
324 // components from many different strings.
325 void SetupOverrideComponents(const char* base,
326                              const Replacements<char>&,
327                              URLComponentSource<char>*,
328                              URLSegments* parsed);
329
330 // Like the above 8-bit version, except that it additionally converts the
331 // UTF-16 input to UTF-8 before doing the overrides.
332 //
333 // The given utf8Buffer is used to store the converted components. They will
334 // be appended one after another, with the parsed structure identifying the
335 // appropriate substrings. This buffer is a parameter because the source has
336 // no storage, so the buffer must have the same lifetime as the source
337 // parameter owned by the caller.
338 //
339 // THE CALLER MUST NOT ADD TO THE |utf8Buffer| AFTER THIS CALL. Members of
340 // |source| will point into this buffer, which could be invalidated if
341 // additional data is added and the CanonOutput resizes its buffer.
342 //
343 // Returns true on success. Fales means that the input was not valid UTF-16,
344 // although we will have still done the override with "invalid characters" in
345 // place of errors.
346 bool SetupUTF16OverrideComponents(const char* base,
347                                   const Replacements<UChar>&,
348                                   URLBuffer<char>& utf8Buffer,
349                                   URLComponentSource<char>*,
350                                   URLSegments* parsed);
351
352 // Implemented in URLCanonicalizer_path.cc, these are required by the relative URL
353 // resolver as well, so we declare them here.
354 bool CanonicalizePartialPath(const char* spec,
355                              const URLComponent& path,
356                              int pathBeginInOutput,
357                              URLBuffer<char>& output);
358 bool CanonicalizePartialPath(const UChar* spec,
359                              const URLComponent& path,
360                              int pathBeginInOutput,
361                              URLBuffer<char>& output);
362
363 #if !OS(WINDOWS)
364 // Implementations of Windows' int-to-string conversions
365 int _itoa_s(int value, char* buffer, size_t sizeInChars, int radix);
366 int _itow_s(int value, UChar* buffer, size_t sizeInChars, int radix);
367
368 // Secure template overloads for these functions
369 template<size_t N>
370 inline int _itoa_s(int value, char (&buffer)[N], int radix)
371 {
372     return _itoa_s(value, buffer, N, radix);
373 }
374
375 template<size_t N>
376 inline int _itow_s(int value, UChar (&buffer)[N], int radix)
377 {
378     return _itow_s(value, buffer, N, radix);
379 }
380
381 // _strtoui64 and strtoull behave the same
382 inline unsigned long long _strtoui64(const char* nptr, char** endptr, int base)
383 {
384     return strtoull(nptr, endptr, base);
385 }
386 #endif // OS(WINDOWS)
387
388 } // namespace URLCanonicalizer
389
390 } // namespace WTF
391
392 #endif // USE(WTFURL)
393
394 #endif // URLCanonInternal_h