Long URLs in error messages should be shortened
[WebKit-https.git] / Source / WebCore / platform / KURL.cpp
1 /*
2  * Copyright (C) 2004, 2007, 2008, 2011, 2012 Apple Inc. All rights reserved.
3  * Copyright (C) 2012 Research In Motion Limited. 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
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE COMPUTER, INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "KURL.h"
29
30 #include "DecodeEscapeSequences.h"
31 #include "MIMETypeRegistry.h"
32 #include "PlatformMemoryInstrumentation.h"
33 #include "TextEncoding.h"
34 #include <stdio.h>
35 #include <wtf/HashMap.h>
36 #if !USE(WTFURL)
37 #include <wtf/HexNumber.h>
38 #endif
39 #include <wtf/MemoryInstrumentationString.h>
40 #include <wtf/StdLibExtras.h>
41 #include <wtf/text/CString.h>
42 #include <wtf/text/StringBuilder.h>
43 #include <wtf/text/StringHash.h>
44
45 #if USE(ICU_UNICODE)
46 #include <unicode/uidna.h>
47 #endif
48
49 // FIXME: This file makes too much use of the + operator on String.
50 // We either have to optimize that operator so it doesn't involve
51 // so many allocations, or change this to use StringBuffer instead.
52
53 using namespace std;
54 using namespace WTF;
55
56 namespace WebCore {
57
58 typedef Vector<char, 512> CharBuffer;
59 typedef Vector<UChar, 512> UCharBuffer;
60
61 static const unsigned maximumValidPortNumber = 0xFFFE;
62 static const unsigned invalidPortNumber = 0xFFFF;
63
64 static inline bool isLetterMatchIgnoringCase(UChar character, char lowercaseLetter)
65 {
66     ASSERT(isASCIILower(lowercaseLetter));
67     return (character | 0x20) == lowercaseLetter;
68 }
69
70 #if !USE(GOOGLEURL) && !USE(WTFURL)
71
72 static const char wsScheme[] = {'w', 's'};
73 static const char ftpScheme[] = {'f', 't', 'p'};
74 static const char ftpPort[] = {'2', '1'};
75 static const char wssScheme[] = {'w', 's', 's'};
76 static const char fileScheme[] = {'f', 'i', 'l', 'e'};
77 static const char httpScheme[] = {'h', 't', 't', 'p'};
78 static const char httpPort[] = {'8', '0'};
79 static const char httpsScheme[] = {'h', 't', 't', 'p', 's'};
80 static const char httpsPort[] = {'4', '4', '3'};
81 static const char gopherScheme[] = {'g', 'o', 'p', 'h', 'e', 'r'};
82 static const char gopherPort[] = {'7', '0'};
83
84 static inline bool isLetterMatchIgnoringCase(char character, char lowercaseLetter)
85 {
86     ASSERT(isASCIILower(lowercaseLetter));
87     return (character | 0x20) == lowercaseLetter;
88 }
89
90 enum URLCharacterClasses {
91     // alpha 
92     SchemeFirstChar = 1 << 0,
93
94     // ( alpha | digit | "+" | "-" | "." )
95     SchemeChar = 1 << 1,
96
97     // mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
98     // unreserved  = alphanum | mark
99     // ( unreserved | escaped | ";" | ":" | "&" | "=" | "+" | "$" | "," )
100     UserInfoChar = 1 << 2,
101
102     // alnum | "." | "-" | "%"
103     // The above is what the specification says, but we are lenient to
104     // match existing practice and also allow:
105     // "_"
106     HostnameChar = 1 << 3,
107
108     // hexdigit | ":" | "%"
109     IPv6Char = 1 << 4,
110
111     // "#" | "?" | "/" | nul
112     PathSegmentEndChar = 1 << 5,
113
114     // not allowed in path
115     BadChar = 1 << 6
116 };
117
118 static const unsigned char characterClassTable[256] = {
119     /* 0 nul */ PathSegmentEndChar,    /* 1 soh */ BadChar,
120     /* 2 stx */ BadChar,    /* 3 etx */ BadChar,
121     /* 4 eot */ BadChar,    /* 5 enq */ BadChar,    /* 6 ack */ BadChar,    /* 7 bel */ BadChar,
122     /* 8 bs */ BadChar,     /* 9 ht */ BadChar,     /* 10 nl */ BadChar,    /* 11 vt */ BadChar,
123     /* 12 np */ BadChar,    /* 13 cr */ BadChar,    /* 14 so */ BadChar,    /* 15 si */ BadChar,
124     /* 16 dle */ BadChar,   /* 17 dc1 */ BadChar,   /* 18 dc2 */ BadChar,   /* 19 dc3 */ BadChar,
125     /* 20 dc4 */ BadChar,   /* 21 nak */ BadChar,   /* 22 syn */ BadChar,   /* 23 etb */ BadChar,
126     /* 24 can */ BadChar,   /* 25 em */ BadChar,    /* 26 sub */ BadChar,   /* 27 esc */ BadChar,
127     /* 28 fs */ BadChar,    /* 29 gs */ BadChar,    /* 30 rs */ BadChar,    /* 31 us */ BadChar,
128     /* 32 sp */ BadChar,    /* 33  ! */ UserInfoChar,
129     /* 34  " */ BadChar,    /* 35  # */ PathSegmentEndChar | BadChar,
130     /* 36  $ */ UserInfoChar,    /* 37  % */ UserInfoChar | HostnameChar | IPv6Char | BadChar,
131     /* 38  & */ UserInfoChar,    /* 39  ' */ UserInfoChar,
132     /* 40  ( */ UserInfoChar,    /* 41  ) */ UserInfoChar,
133     /* 42  * */ UserInfoChar,    /* 43  + */ SchemeChar | UserInfoChar,
134     /* 44  , */ UserInfoChar,
135     /* 45  - */ SchemeChar | UserInfoChar | HostnameChar,
136     /* 46  . */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
137     /* 47  / */ PathSegmentEndChar,
138     /* 48  0 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
139     /* 49  1 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,    
140     /* 50  2 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
141     /* 51  3 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
142     /* 52  4 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
143     /* 53  5 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
144     /* 54  6 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
145     /* 55  7 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
146     /* 56  8 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
147     /* 57  9 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
148     /* 58  : */ UserInfoChar | IPv6Char,    /* 59  ; */ UserInfoChar,
149     /* 60  < */ BadChar,    /* 61  = */ UserInfoChar,
150     /* 62  > */ BadChar,    /* 63  ? */ PathSegmentEndChar | BadChar,
151     /* 64  @ */ 0,
152     /* 65  A */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,    
153     /* 66  B */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
154     /* 67  C */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
155     /* 68  D */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
156     /* 69  E */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
157     /* 70  F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
158     /* 71  G */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
159     /* 72  H */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
160     /* 73  I */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
161     /* 74  J */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
162     /* 75  K */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
163     /* 76  L */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
164     /* 77  M */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
165     /* 78  N */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
166     /* 79  O */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
167     /* 80  P */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
168     /* 81  Q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
169     /* 82  R */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
170     /* 83  S */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
171     /* 84  T */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
172     /* 85  U */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
173     /* 86  V */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
174     /* 87  W */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
175     /* 88  X */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
176     /* 89  Y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
177     /* 90  Z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
178     /* 91  [ */ 0,
179     /* 92  \ */ 0,    /* 93  ] */ 0,
180     /* 94  ^ */ 0,
181     /* 95  _ */ UserInfoChar | HostnameChar,
182     /* 96  ` */ 0,
183     /* 97  a */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
184     /* 98  b */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
185     /* 99  c */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
186     /* 100  d */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
187     /* 101  e */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
188     /* 102  f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
189     /* 103  g */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
190     /* 104  h */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
191     /* 105  i */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
192     /* 106  j */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
193     /* 107  k */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
194     /* 108  l */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
195     /* 109  m */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
196     /* 110  n */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
197     /* 111  o */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
198     /* 112  p */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
199     /* 113  q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
200     /* 114  r */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
201     /* 115  s */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
202     /* 116  t */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
203     /* 117  u */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
204     /* 118  v */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
205     /* 119  w */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
206     /* 120  x */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
207     /* 121  y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
208     /* 122  z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
209     /* 123  { */ 0,
210     /* 124  | */ 0,   /* 125  } */ 0,   /* 126  ~ */ UserInfoChar,   /* 127 del */ BadChar,
211     /* 128 */ BadChar, /* 129 */ BadChar, /* 130 */ BadChar, /* 131 */ BadChar,
212     /* 132 */ BadChar, /* 133 */ BadChar, /* 134 */ BadChar, /* 135 */ BadChar,
213     /* 136 */ BadChar, /* 137 */ BadChar, /* 138 */ BadChar, /* 139 */ BadChar,
214     /* 140 */ BadChar, /* 141 */ BadChar, /* 142 */ BadChar, /* 143 */ BadChar,
215     /* 144 */ BadChar, /* 145 */ BadChar, /* 146 */ BadChar, /* 147 */ BadChar,
216     /* 148 */ BadChar, /* 149 */ BadChar, /* 150 */ BadChar, /* 151 */ BadChar,
217     /* 152 */ BadChar, /* 153 */ BadChar, /* 154 */ BadChar, /* 155 */ BadChar,
218     /* 156 */ BadChar, /* 157 */ BadChar, /* 158 */ BadChar, /* 159 */ BadChar,
219     /* 160 */ BadChar, /* 161 */ BadChar, /* 162 */ BadChar, /* 163 */ BadChar,
220     /* 164 */ BadChar, /* 165 */ BadChar, /* 166 */ BadChar, /* 167 */ BadChar,
221     /* 168 */ BadChar, /* 169 */ BadChar, /* 170 */ BadChar, /* 171 */ BadChar,
222     /* 172 */ BadChar, /* 173 */ BadChar, /* 174 */ BadChar, /* 175 */ BadChar,
223     /* 176 */ BadChar, /* 177 */ BadChar, /* 178 */ BadChar, /* 179 */ BadChar,
224     /* 180 */ BadChar, /* 181 */ BadChar, /* 182 */ BadChar, /* 183 */ BadChar,
225     /* 184 */ BadChar, /* 185 */ BadChar, /* 186 */ BadChar, /* 187 */ BadChar,
226     /* 188 */ BadChar, /* 189 */ BadChar, /* 190 */ BadChar, /* 191 */ BadChar,
227     /* 192 */ BadChar, /* 193 */ BadChar, /* 194 */ BadChar, /* 195 */ BadChar,
228     /* 196 */ BadChar, /* 197 */ BadChar, /* 198 */ BadChar, /* 199 */ BadChar,
229     /* 200 */ BadChar, /* 201 */ BadChar, /* 202 */ BadChar, /* 203 */ BadChar,
230     /* 204 */ BadChar, /* 205 */ BadChar, /* 206 */ BadChar, /* 207 */ BadChar,
231     /* 208 */ BadChar, /* 209 */ BadChar, /* 210 */ BadChar, /* 211 */ BadChar,
232     /* 212 */ BadChar, /* 213 */ BadChar, /* 214 */ BadChar, /* 215 */ BadChar,
233     /* 216 */ BadChar, /* 217 */ BadChar, /* 218 */ BadChar, /* 219 */ BadChar,
234     /* 220 */ BadChar, /* 221 */ BadChar, /* 222 */ BadChar, /* 223 */ BadChar,
235     /* 224 */ BadChar, /* 225 */ BadChar, /* 226 */ BadChar, /* 227 */ BadChar,
236     /* 228 */ BadChar, /* 229 */ BadChar, /* 230 */ BadChar, /* 231 */ BadChar,
237     /* 232 */ BadChar, /* 233 */ BadChar, /* 234 */ BadChar, /* 235 */ BadChar,
238     /* 236 */ BadChar, /* 237 */ BadChar, /* 238 */ BadChar, /* 239 */ BadChar,
239     /* 240 */ BadChar, /* 241 */ BadChar, /* 242 */ BadChar, /* 243 */ BadChar,
240     /* 244 */ BadChar, /* 245 */ BadChar, /* 246 */ BadChar, /* 247 */ BadChar,
241     /* 248 */ BadChar, /* 249 */ BadChar, /* 250 */ BadChar, /* 251 */ BadChar,
242     /* 252 */ BadChar, /* 253 */ BadChar, /* 254 */ BadChar, /* 255 */ BadChar
243 };
244
245 static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd);
246 static void encodeRelativeString(const String& rel, const TextEncoding&, CharBuffer& ouput);
247 static String substituteBackslashes(const String&);
248
249 static inline bool isSchemeFirstChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & SchemeFirstChar; }
250 static inline bool isSchemeFirstChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeFirstChar); }
251 static inline bool isSchemeChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & SchemeChar; }
252 static inline bool isSchemeChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeChar); }
253 static inline bool isUserInfoChar(unsigned char c) { return characterClassTable[c] & UserInfoChar; }
254 static inline bool isHostnameChar(unsigned char c) { return characterClassTable[c] & HostnameChar; }
255 static inline bool isIPv6Char(unsigned char c) { return characterClassTable[c] & IPv6Char; }
256 static inline bool isPathSegmentEndChar(char c) { return characterClassTable[static_cast<unsigned char>(c)] & PathSegmentEndChar; }
257 static inline bool isPathSegmentEndChar(UChar c) { return c <= 0xff && (characterClassTable[c] & PathSegmentEndChar); }
258 static inline bool isBadChar(unsigned char c) { return characterClassTable[c] & BadChar; }
259     
260 static inline bool isSchemeCharacterMatchIgnoringCase(char character, char schemeCharacter)
261 {
262     ASSERT(isSchemeChar(character));
263     ASSERT(schemeCharacter & 0x20);
264     ASSERT(isASCIILower(schemeCharacter) || (!isASCIIUpper(schemeCharacter) && isSchemeChar(schemeCharacter)));
265     return (character | 0x20) == schemeCharacter;
266 }
267
268 // Copies the source to the destination, assuming all the source characters are
269 // ASCII. The destination buffer must be large enough. Null characters are allowed
270 // in the source string, and no attempt is made to null-terminate the result.
271 static void copyASCII(const String& string, char* dest)
272 {
273     if (string.isEmpty())
274         return;
275
276     if (string.is8Bit())
277         memcpy(dest, string.characters8(), string.length());
278     else {
279         const UChar* src = string.characters16();
280         size_t length = string.length();
281         for (size_t i = 0; i < length; i++)
282             dest[i] = static_cast<char>(src[i]);
283     }
284 }
285
286 static void appendASCII(const String& base, const char* rel, size_t len, CharBuffer& buffer)
287 {
288     buffer.resize(base.length() + len + 1);
289     copyASCII(base, buffer.data());
290     memcpy(buffer.data() + base.length(), rel, len);
291     buffer[buffer.size() - 1] = '\0';
292 }
293
294 // FIXME: Move to WTFString.h eventually.
295 // Returns the index of the first index in string |s| of any of the characters
296 // in |toFind|. |toFind| should be a null-terminated string, all characters up
297 // to the null will be searched. Returns int if not found.
298 static int findFirstOf(const UChar* s, int sLen, int startPos, const char* toFind)
299 {
300     for (int i = startPos; i < sLen; i++) {
301         const char* cur = toFind;
302         while (*cur) {
303             if (s[i] == *(cur++))
304                 return i;
305         }
306     }
307     return -1;
308 }
309
310 static inline void checkEncodedString(const String& url)
311 {
312     ASSERT_UNUSED(url, url.containsOnlyASCII());
313     ASSERT_UNUSED(url, url.isEmpty() || isSchemeFirstChar(url[0]));
314 }
315
316 inline bool KURL::protocolIs(const String& string, const char* protocol)
317 {
318     return WebCore::protocolIs(string, protocol);
319 }
320
321 void KURL::invalidate()
322 {
323     m_isValid = false;
324     m_protocolIsInHTTPFamily = false;
325     m_schemeEnd = 0;
326     m_userStart = 0;
327     m_userEnd = 0;
328     m_passwordEnd = 0;
329     m_hostEnd = 0;
330     m_portEnd = 0;
331     m_pathEnd = 0;
332     m_pathAfterLastSlash = 0;
333     m_queryEnd = 0;
334     m_fragmentEnd = 0;
335 }
336
337 KURL::KURL(ParsedURLStringTag, const String& url)
338 {
339     parse(url);
340     ASSERT(url == m_string);
341 }
342
343 KURL::KURL(const KURL& base, const String& relative)
344 {
345     init(base, relative, UTF8Encoding());
346 }
347
348 KURL::KURL(const KURL& base, const String& relative, const TextEncoding& encoding)
349 {
350     // For UTF-{7,16,32}, we want to use UTF-8 for the query part as 
351     // we do when submitting a form. A form with GET method
352     // has its contents added to a URL as query params and it makes sense
353     // to be consistent.
354     init(base, relative, encoding.encodingForFormSubmission());
355 }
356
357 static bool shouldTrimFromURL(unsigned char c)
358 {
359     // Browsers ignore leading/trailing whitespace and control
360     // characters from URLs.  Note that c is an *unsigned* char here
361     // so this comparison should only catch control characters.
362     return c <= ' ';
363 }
364
365 void KURL::init(const KURL& base, const String& relative, const TextEncoding& encoding)
366 {
367     // Allow resolutions with a null or empty base URL, but not with any other invalid one.
368     // FIXME: Is this a good rule?
369     if (!base.m_isValid && !base.isEmpty()) {
370         m_string = relative;
371         invalidate();
372         return;
373     }
374
375     // For compatibility with Win IE, treat backslashes as if they were slashes,
376     // as long as we're not dealing with javascript: or data: URLs.
377     String rel = relative;
378     if (rel.contains('\\') && !(protocolIsJavaScript(rel) || protocolIs(rel, "data")))
379         rel = substituteBackslashes(rel);
380
381     bool allASCII = rel.containsOnlyASCII();
382     CharBuffer strBuffer;
383     char* str;
384     size_t len;
385     if (allASCII) {
386         len = rel.length();
387         strBuffer.resize(len + 1);
388         copyASCII(rel, strBuffer.data());
389         strBuffer[len] = 0;
390         str = strBuffer.data();
391     } else {
392         encodeRelativeString(rel, encoding, strBuffer);
393         str = strBuffer.data();
394         len = strlen(str);
395     }
396
397     // Get rid of leading whitespace and control characters.
398     while (len && shouldTrimFromURL(*str)) {
399         str++;
400         --len;
401     }
402
403     // Get rid of trailing whitespace and control characters.
404     while (len && shouldTrimFromURL(str[len - 1]))
405         str[--len] = '\0';
406
407     // According to the RFC, the reference should be interpreted as an
408     // absolute URI if possible, using the "leftmost, longest"
409     // algorithm. If the URI reference is absolute it will have a
410     // scheme, meaning that it will have a colon before the first
411     // non-scheme element.
412     bool absolute = false;
413     char* p = str;
414     if (isSchemeFirstChar(*p)) {
415         ++p;
416         while (isSchemeChar(*p)) {
417             ++p;
418         }
419         if (*p == ':') {
420             if (p[1] != '/' && equalIgnoringCase(base.protocol(), String(str, p - str)) && base.isHierarchical())
421                 str = p + 1;
422             else
423                 absolute = true;
424         }
425     }
426
427     CharBuffer parseBuffer;
428
429     if (absolute) {
430         parse(str, &relative);
431     } else {
432         // If the base is empty or opaque (e.g. data: or javascript:), then the URL is invalid
433         // unless the relative URL is a single fragment.
434         if (!base.isHierarchical()) {
435             if (str[0] == '#') {
436                 appendASCII(base.m_string.left(base.m_queryEnd), str, len, parseBuffer);
437                 parse(parseBuffer.data(), &relative);
438             } else {
439                 m_string = relative;
440                 invalidate();
441             }
442             return;
443         }
444
445         switch (str[0]) {
446         case '\0':
447             // The reference is empty, so this is a reference to the same document with any fragment identifier removed.
448             *this = base;
449             removeFragmentIdentifier();
450             break;
451         case '#': {
452             // must be fragment-only reference
453             appendASCII(base.m_string.left(base.m_queryEnd), str, len, parseBuffer);
454             parse(parseBuffer.data(), &relative);
455             break;
456         }
457         case '?': {
458             // query-only reference, special case needed for non-URL results
459             appendASCII(base.m_string.left(base.m_pathEnd), str, len, parseBuffer);
460             parse(parseBuffer.data(), &relative);
461             break;
462         }
463         case '/':
464             // must be net-path or absolute-path reference
465             if (str[1] == '/') {
466                 // net-path
467                 appendASCII(base.m_string.left(base.m_schemeEnd + 1), str, len, parseBuffer);
468                 parse(parseBuffer.data(), &relative);
469             } else {
470                 // abs-path
471                 appendASCII(base.m_string.left(base.m_portEnd), str, len, parseBuffer);
472                 parse(parseBuffer.data(), &relative);
473             }
474             break;
475         default:
476             {
477                 // must be relative-path reference
478
479                 // Base part plus relative part plus one possible slash added in between plus terminating \0 byte.
480                 const size_t bufferSize = base.m_pathEnd + 1 + len + 1;
481                 parseBuffer.resize(bufferSize);
482
483                 char* bufferPos = parseBuffer.data();
484                 char* bufferStart = bufferPos;
485
486                 // first copy everything before the path from the base
487                 CharBuffer baseStringBuffer(base.m_string.length());
488                 copyASCII(base.m_string, baseStringBuffer.data());
489                 const char* baseString = baseStringBuffer.data();
490                 const char* baseStringStart = baseString;
491                 const char* pathStart = baseStringStart + base.m_portEnd;
492                 while (baseStringStart < pathStart)
493                     *bufferPos++ = *baseStringStart++;
494                 char* bufferPathStart = bufferPos;
495
496                 // now copy the base path
497                 const char* baseStringEnd = baseString + base.m_pathEnd;
498
499                 // go back to the last slash
500                 while (baseStringEnd > baseStringStart && baseStringEnd[-1] != '/')
501                     baseStringEnd--;
502
503                 if (baseStringEnd == baseStringStart) {
504                     // no path in base, add a path separator if necessary
505                     if (base.m_schemeEnd + 1 != base.m_pathEnd && *str && *str != '?' && *str != '#')
506                         *bufferPos++ = '/';
507                 } else {
508                     bufferPos += copyPathRemovingDots(bufferPos, baseStringStart, 0, baseStringEnd - baseStringStart);
509                 }
510
511                 const char* relStringStart = str;
512                 const char* relStringPos = relStringStart;
513
514                 while (*relStringPos && *relStringPos != '?' && *relStringPos != '#') {
515                     if (relStringPos[0] == '.' && bufferPos[-1] == '/') {
516                         if (isPathSegmentEndChar(relStringPos[1])) {
517                             // skip over "." segment
518                             relStringPos += 1;
519                             if (relStringPos[0] == '/')
520                                 relStringPos++;
521                             continue;
522                         } else if (relStringPos[1] == '.' && isPathSegmentEndChar(relStringPos[2])) {
523                             // skip over ".." segment and rewind the last segment
524                             // the RFC leaves it up to the app to decide what to do with excess
525                             // ".." segments - we choose to drop them since some web content
526                             // relies on this.
527                             relStringPos += 2;
528                             if (relStringPos[0] == '/')
529                                 relStringPos++;
530                             if (bufferPos > bufferPathStart + 1)
531                                 bufferPos--;
532                             while (bufferPos > bufferPathStart + 1  && bufferPos[-1] != '/')
533                                 bufferPos--;
534                             continue;
535                         }
536                     }
537
538                     *bufferPos = *relStringPos;
539                     relStringPos++;
540                     bufferPos++;
541                 }
542
543                 // all done with the path work, now copy any remainder
544                 // of the relative reference; this will also add a null terminator
545                 strncpy(bufferPos, relStringPos, bufferSize - (bufferPos - bufferStart));
546
547                 parse(parseBuffer.data(), &relative);
548
549                 ASSERT(strlen(parseBuffer.data()) + 1 <= parseBuffer.size());
550                 break;
551             }
552         }
553     }
554 }
555
556 KURL KURL::copy() const
557 {
558     KURL result = *this;
559     result.m_string = result.m_string.isolatedCopy();
560     return result;
561 }
562
563 String KURL::lastPathComponent() const
564 {
565     if (!hasPath())
566         return String();
567
568     unsigned end = m_pathEnd - 1;
569     if (m_string[end] == '/')
570         --end;
571
572     size_t start = m_string.reverseFind('/', end);
573     if (start < static_cast<unsigned>(m_portEnd))
574         return String();
575     ++start;
576
577     return m_string.substring(start, end - start + 1);
578 }
579
580 String KURL::protocol() const
581 {
582     return m_string.left(m_schemeEnd);
583 }
584
585 String KURL::host() const
586 {
587     int start = hostStart();
588     return decodeURLEscapeSequences(m_string.substring(start, m_hostEnd - start));
589 }
590
591 unsigned short KURL::port() const
592 {
593     // We return a port of 0 if there is no port specified. This can happen in two situations:
594     // 1) The URL contains no colon after the host name and before the path component of the URL.
595     // 2) The URL contains a colon but there's no port number before the path component of the URL begins.
596     if (m_hostEnd == m_portEnd || m_hostEnd == m_portEnd - 1)
597         return 0;
598
599     const UChar* stringData = m_string.characters();
600     bool ok = false;
601     unsigned number = charactersToUIntStrict(stringData + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
602     if (!ok || number > maximumValidPortNumber)
603         return invalidPortNumber;
604     return number;
605 }
606
607 String KURL::pass() const
608 {
609     if (m_passwordEnd == m_userEnd)
610         return String();
611
612     return decodeURLEscapeSequences(m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1)); 
613 }
614
615 String KURL::user() const
616 {
617     return decodeURLEscapeSequences(m_string.substring(m_userStart, m_userEnd - m_userStart));
618 }
619
620 String KURL::fragmentIdentifier() const
621 {
622     if (m_fragmentEnd == m_queryEnd)
623         return String();
624
625     return m_string.substring(m_queryEnd + 1, m_fragmentEnd - (m_queryEnd + 1));
626 }
627
628 bool KURL::hasFragmentIdentifier() const
629 {
630     return m_fragmentEnd != m_queryEnd;
631 }
632
633 String KURL::baseAsString() const
634 {
635     return m_string.left(m_pathAfterLastSlash);
636 }
637
638 #ifdef NDEBUG
639
640 static inline void assertProtocolIsGood(const char*)
641 {
642 }
643
644 #else
645
646 static void assertProtocolIsGood(const char* protocol)
647 {
648     const char* p = protocol;
649     while (*p) {
650         ASSERT(*p > ' ' && *p < 0x7F && !(*p >= 'A' && *p <= 'Z'));
651         ++p;
652     }
653 }
654
655 #endif
656
657 bool KURL::protocolIs(const char* protocol) const
658 {
659     assertProtocolIsGood(protocol);
660
661     // JavaScript URLs are "valid" and should be executed even if KURL decides they are invalid.
662     // The free function protocolIsJavaScript() should be used instead. 
663     ASSERT(!equalIgnoringCase(protocol, String("javascript")));
664
665     if (!m_isValid)
666         return false;
667
668     // Do the comparison without making a new string object.
669     for (int i = 0; i < m_schemeEnd; ++i) {
670         if (!protocol[i] || !isSchemeCharacterMatchIgnoringCase(m_string[i], protocol[i]))
671             return false;
672     }
673     return !protocol[m_schemeEnd]; // We should have consumed all characters in the argument.
674 }
675
676 String KURL::query() const
677 {
678     if (m_queryEnd == m_pathEnd)
679         return String();
680
681     return m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); 
682 }
683
684 String KURL::path() const
685 {
686     return m_string.substring(m_portEnd, m_pathEnd - m_portEnd);
687 }
688
689 bool KURL::setProtocol(const String& s)
690 {
691     // Firefox and IE remove everything after the first ':'.
692     size_t separatorPosition = s.find(':');
693     String newProtocol = s.substring(0, separatorPosition);
694
695     if (!isValidProtocol(newProtocol))
696         return false;
697
698     if (!m_isValid) {
699         parse(newProtocol + ":" + m_string);
700         return true;
701     }
702
703     parse(newProtocol + m_string.substring(m_schemeEnd));
704     return true;
705 }
706
707 void KURL::setHost(const String& s)
708 {
709     if (!m_isValid)
710         return;
711
712     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
713     // and to avoid changing more than just the host.
714
715     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
716
717     parse(m_string.left(hostStart()) + (slashSlashNeeded ? "//" : "") + s + m_string.substring(m_hostEnd));
718 }
719
720 void KURL::removePort()
721 {
722     if (m_hostEnd == m_portEnd)
723         return;
724     parse(m_string.left(m_hostEnd) + m_string.substring(m_portEnd));
725 }
726
727 void KURL::setPort(unsigned short i)
728 {
729     if (!m_isValid)
730         return;
731
732     bool colonNeeded = m_portEnd == m_hostEnd;
733     int portStart = (colonNeeded ? m_hostEnd : m_hostEnd + 1);
734
735     parse(m_string.left(portStart) + (colonNeeded ? ":" : "") + String::number(i) + m_string.substring(m_portEnd));
736 }
737
738 void KURL::setHostAndPort(const String& hostAndPort)
739 {
740     if (!m_isValid)
741         return;
742
743     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
744     // and to avoid changing more than just host and port.
745
746     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
747
748     parse(m_string.left(hostStart()) + (slashSlashNeeded ? "//" : "") + hostAndPort + m_string.substring(m_portEnd));
749 }
750
751 void KURL::setUser(const String& user)
752 {
753     if (!m_isValid)
754         return;
755
756     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
757     // and to avoid changing more than just the user login.
758
759     int end = m_userEnd;
760     if (!user.isEmpty()) {
761         String u = user;
762         if (m_userStart == m_schemeEnd + 1)
763             u = "//" + u;
764         // Add '@' if we didn't have one before.
765         if (end == m_hostEnd || (end == m_passwordEnd && m_string[end] != '@'))
766             u.append('@');
767         parse(m_string.left(m_userStart) + u + m_string.substring(end));
768     } else {
769         // Remove '@' if we now have neither user nor password.
770         if (m_userEnd == m_passwordEnd && end != m_hostEnd && m_string[end] == '@')
771             end += 1;
772         // We don't want to parse in the extremely common case where we are not going to make a change.
773         if (m_userStart != end)
774             parse(m_string.left(m_userStart) + m_string.substring(end));
775     }
776 }
777
778 void KURL::setPass(const String& password)
779 {
780     if (!m_isValid)
781         return;
782
783     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
784     // and to avoid changing more than just the user password.
785
786     int end = m_passwordEnd;
787     if (!password.isEmpty()) {
788         String p = ":" + password + "@";
789         if (m_userEnd == m_schemeEnd + 1)
790             p = "//" + p;
791         // Eat the existing '@' since we are going to add our own.
792         if (end != m_hostEnd && m_string[end] == '@')
793             end += 1;
794         parse(m_string.left(m_userEnd) + p + m_string.substring(end));
795     } else {
796         // Remove '@' if we now have neither user nor password.
797         if (m_userStart == m_userEnd && end != m_hostEnd && m_string[end] == '@')
798             end += 1;
799         // We don't want to parse in the extremely common case where we are not going to make a change.
800         if (m_userEnd != end)
801             parse(m_string.left(m_userEnd) + m_string.substring(end));
802     }
803 }
804
805 void KURL::setFragmentIdentifier(const String& s)
806 {
807     if (!m_isValid)
808         return;
809
810     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations.
811     parse(m_string.left(m_queryEnd) + "#" + s);
812 }
813
814 void KURL::removeFragmentIdentifier()
815 {
816     if (!m_isValid)
817         return;
818     parse(m_string.left(m_queryEnd));
819 }
820     
821 void KURL::setQuery(const String& query)
822 {
823     if (!m_isValid)
824         return;
825
826     // FIXME: '#' and non-ASCII characters must be encoded and escaped.
827     // Usually, the query is encoded using document encoding, not UTF-8, but we don't have
828     // access to the document in this function.
829     if ((query.isEmpty() || query[0] != '?') && !query.isNull())
830         parse(m_string.left(m_pathEnd) + "?" + query + m_string.substring(m_queryEnd));
831     else
832         parse(m_string.left(m_pathEnd) + query + m_string.substring(m_queryEnd));
833
834 }
835
836 void KURL::setPath(const String& s)
837 {
838     if (!m_isValid)
839         return;
840
841     // FIXME: encodeWithURLEscapeSequences does not correctly escape '#' and '?', so fragment and query parts
842     // may be inadvertently affected.
843     String path = s;
844     if (path.isEmpty() || path[0] != '/')
845         path = "/" + path;
846
847     parse(m_string.left(m_portEnd) + encodeWithURLEscapeSequences(path) + m_string.substring(m_pathEnd));
848 }
849
850 String decodeURLEscapeSequences(const String& string)
851 {
852     return decodeEscapeSequences<URLEscapeSequence>(string, UTF8Encoding());
853 }
854
855 String decodeURLEscapeSequences(const String& string, const TextEncoding& encoding)
856 {
857     return decodeEscapeSequences<URLEscapeSequence>(string, encoding);
858 }
859
860 // Caution: This function does not bounds check.
861 static void appendEscapedChar(char*& buffer, unsigned char c)
862 {
863     *buffer++ = '%';
864     placeByteAsHex(c, buffer);
865 }
866
867 static void appendEscapingBadChars(char*& buffer, const char* strStart, size_t length)
868 {
869     char* p = buffer;
870
871     const char* str = strStart;
872     const char* strEnd = strStart + length;
873     while (str < strEnd) {
874         unsigned char c = *str++;
875         if (isBadChar(c)) {
876             if (c == '%' || c == '?')
877                 *p++ = c;
878             else if (c != 0x09 && c != 0x0a && c != 0x0d)
879                 appendEscapedChar(p, c);
880         } else
881             *p++ = c;
882     }
883
884     buffer = p;
885 }
886
887 static void escapeAndAppendNonHierarchicalPart(char*& buffer, const char* strStart, size_t length)
888 {
889     char* p = buffer;
890
891     const char* str = strStart;
892     const char* strEnd = strStart + length;
893     while (str < strEnd) {
894         unsigned char c = *str++;
895         // Strip CR, LF and Tab from fragments, per:
896         // https://bugs.webkit.org/show_bug.cgi?id=8770
897         if (c == 0x09 || c == 0x0a || c == 0x0d)
898             continue;
899
900         // Chrome and IE allow non-ascii characters in fragments, however doing
901         // so would hit an ASSERT in checkEncodedString, so for now we don't.
902         if (c < 0x20 || c >= 127) {
903             appendEscapedChar(p, c);
904             continue;
905         }
906         *p++ = c;
907     }
908
909     buffer = p;
910 }
911
912 // copy a path, accounting for "." and ".." segments
913 static int copyPathRemovingDots(char* dst, const char* src, int srcStart, int srcEnd)
914 {
915     char* bufferPathStart = dst;
916
917     // empty path is a special case, and need not have a leading slash
918     if (srcStart != srcEnd) {
919         const char* baseStringStart = src + srcStart;
920         const char* baseStringEnd = src + srcEnd;
921         const char* baseStringPos = baseStringStart;
922
923         // this code is unprepared for paths that do not begin with a
924         // slash and we should always have one in the source string
925         ASSERT(baseStringPos[0] == '/');
926
927         // copy the leading slash into the destination
928         *dst = *baseStringPos;
929         baseStringPos++;
930         dst++;
931
932         while (baseStringPos < baseStringEnd) {
933             if (baseStringPos[0] == '.' && dst[-1] == '/') {
934                 if (baseStringPos[1] == '/' || baseStringPos + 1 == baseStringEnd) {
935                     // skip over "." segment
936                     baseStringPos += 2;
937                     continue;
938                 } else if (baseStringPos[1] == '.' && (baseStringPos[2] == '/' ||
939                                        baseStringPos + 2 == baseStringEnd)) {
940                     // skip over ".." segment and rewind the last segment
941                     // the RFC leaves it up to the app to decide what to do with excess
942                     // ".." segments - we choose to drop them since some web content
943                     // relies on this.
944                     baseStringPos += 3;
945                     if (dst > bufferPathStart + 1)
946                         dst--;
947                     while (dst > bufferPathStart && dst[-1] != '/')
948                         dst--;
949                     continue;
950                 }
951             }
952
953             *dst = *baseStringPos;
954             baseStringPos++;
955             dst++;
956         }
957     }
958     *dst = '\0';
959     return dst - bufferPathStart;
960 }
961
962 static inline bool hasSlashDotOrDotDot(const char* str)
963 {
964     const unsigned char* p = reinterpret_cast<const unsigned char*>(str);
965     if (!*p)
966         return false;
967     unsigned char pc = *p;
968     while (unsigned char c = *++p) {
969         if (c == '.' && (pc == '/' || pc == '.'))
970             return true;
971         pc = c;
972     }
973     return false;
974 }
975
976 void KURL::parse(const String& string)
977 {
978     checkEncodedString(string);
979
980     CharBuffer buffer(string.length() + 1);
981     copyASCII(string, buffer.data());
982     buffer[string.length()] = '\0';
983     parse(buffer.data(), &string);
984 }
985
986 template<size_t length>
987 static inline bool equal(const char* a, const char (&b)[length])
988 {
989     for (size_t i = 0; i < length; ++i) {
990         if (a[i] != b[i])
991             return false;
992     }
993     return true;
994 }
995
996 template<size_t lengthB>
997 static inline bool equal(const char* stringA, size_t lengthA, const char (&stringB)[lengthB])
998 {
999     return lengthA == lengthB && equal(stringA, stringB);
1000 }
1001
1002 // List of default schemes is taken from google-url:
1003 // http://code.google.com/p/google-url/source/browse/trunk/src/url_canon_stdurl.cc#120
1004 static inline bool isDefaultPortForScheme(const char* port, size_t portLength, const char* scheme, size_t schemeLength)
1005 {
1006     // This switch is theoretically a performance optimization.  It came over when
1007     // the code was moved from google-url, but may be removed later.
1008     switch (schemeLength) {
1009     case 2:
1010         return equal(scheme, wsScheme) && equal(port, portLength, httpPort);
1011     case 3:
1012         if (equal(scheme, ftpScheme))
1013             return equal(port, portLength, ftpPort);
1014         if (equal(scheme, wssScheme))
1015             return equal(port, portLength, httpsPort);
1016         break;
1017     case 4:
1018         return equal(scheme, httpScheme) && equal(port, portLength, httpPort);
1019     case 5:
1020         return equal(scheme, httpsScheme) && equal(port, portLength, httpsPort);
1021     case 6:
1022         return equal(scheme, gopherScheme) && equal(port, portLength, gopherPort);
1023     }
1024     return false;
1025 }
1026
1027 static inline bool hostPortIsEmptyButCredentialsArePresent(int hostStart, int portEnd, char userEndChar)
1028 {
1029     return userEndChar == '@' && hostStart == portEnd;
1030 }
1031
1032 static bool isNonFileHierarchicalScheme(const char* scheme, size_t schemeLength)
1033 {
1034     switch (schemeLength) {
1035     case 2:
1036         return equal(scheme, wsScheme);
1037     case 3:
1038         return equal(scheme, ftpScheme) || equal(scheme, wssScheme);
1039     case 4:
1040         return equal(scheme, httpScheme);
1041     case 5:
1042         return equal(scheme, httpsScheme);
1043     case 6:
1044         return equal(scheme, gopherScheme);
1045     }
1046     return false;
1047 }
1048
1049 static bool isCanonicalHostnameLowercaseForScheme(const char* scheme, size_t schemeLength)
1050 {
1051     switch (schemeLength) {
1052     case 2:
1053         return equal(scheme, wsScheme);
1054     case 3:
1055         return equal(scheme, ftpScheme) || equal(scheme, wssScheme);
1056     case 4:
1057         return equal(scheme, httpScheme) || equal(scheme, fileScheme);
1058     case 5:
1059         return equal(scheme, httpsScheme);
1060     case 6:
1061         return equal(scheme, gopherScheme);
1062     }
1063     return false;
1064 }
1065
1066 void KURL::parse(const char* url, const String* originalString)
1067 {
1068     if (!url || url[0] == '\0') {
1069         // valid URL must be non-empty
1070         m_string = originalString ? *originalString : url;
1071         invalidate();
1072         return;
1073     }
1074
1075     if (!isSchemeFirstChar(url[0])) {
1076         // scheme must start with an alphabetic character
1077         m_string = originalString ? *originalString : url;
1078         invalidate();
1079         return;
1080     }
1081
1082     int schemeEnd = 0;
1083     while (isSchemeChar(url[schemeEnd]))
1084         schemeEnd++;
1085
1086     if (url[schemeEnd] != ':') {
1087         m_string = originalString ? *originalString : url;
1088         invalidate();
1089         return;
1090     }
1091
1092     int userStart = schemeEnd + 1;
1093     int userEnd;
1094     int passwordStart;
1095     int passwordEnd;
1096     int hostStart;
1097     int hostEnd;
1098     int portStart;
1099     int portEnd;
1100
1101     bool hierarchical = url[schemeEnd + 1] == '/';
1102     bool hasSecondSlash = hierarchical && url[schemeEnd + 2] == '/';
1103
1104     bool isFile = schemeEnd == 4
1105         && isLetterMatchIgnoringCase(url[0], 'f')
1106         && isLetterMatchIgnoringCase(url[1], 'i')
1107         && isLetterMatchIgnoringCase(url[2], 'l')
1108         && isLetterMatchIgnoringCase(url[3], 'e');
1109
1110 #if PLATFORM(BLACKBERRY)
1111     // Parse local: urls the same as file: urls.
1112     if (!isFile)
1113         isFile = schemeEnd == 5
1114             && isLetterMatchIgnoringCase(url[0], 'l')
1115             && isLetterMatchIgnoringCase(url[1], 'o')
1116             && isLetterMatchIgnoringCase(url[2], 'c')
1117             && isLetterMatchIgnoringCase(url[3], 'a')
1118             && isLetterMatchIgnoringCase(url[4], 'l');
1119 #endif
1120
1121     m_protocolIsInHTTPFamily = isLetterMatchIgnoringCase(url[0], 'h')
1122         && isLetterMatchIgnoringCase(url[1], 't')
1123         && isLetterMatchIgnoringCase(url[2], 't')
1124         && isLetterMatchIgnoringCase(url[3], 'p')
1125         && (url[4] == ':' || (isLetterMatchIgnoringCase(url[4], 's') && url[5] == ':'));
1126
1127     if ((hierarchical && hasSecondSlash) || isNonFileHierarchicalScheme(url, schemeEnd)) {
1128         // The part after the scheme is either a net_path or an abs_path whose first path segment is empty.
1129         // Attempt to find an authority.
1130         // FIXME: Authority characters may be scanned twice, and it would be nice to be faster.
1131
1132         if (hierarchical)
1133             userStart++;
1134         if (hasSecondSlash)
1135             userStart++;
1136         userEnd = userStart;
1137
1138         int colonPos = 0;
1139         while (isUserInfoChar(url[userEnd])) {
1140             if (url[userEnd] == ':' && colonPos == 0)
1141                 colonPos = userEnd;
1142             userEnd++;
1143         }
1144
1145         if (url[userEnd] == '@') {
1146             // actual end of the userinfo, start on the host
1147             if (colonPos != 0) {
1148                 passwordEnd = userEnd;
1149                 userEnd = colonPos;
1150                 passwordStart = colonPos + 1;
1151             } else
1152                 passwordStart = passwordEnd = userEnd;
1153
1154             hostStart = passwordEnd + 1;
1155         } else if (url[userEnd] == '[' || isPathSegmentEndChar(url[userEnd])) {
1156             // hit the end of the authority, must have been no user
1157             // or looks like an IPv6 hostname
1158             // either way, try to parse it as a hostname
1159             userEnd = userStart;
1160             passwordStart = passwordEnd = userEnd;
1161             hostStart = userStart;
1162         } else {
1163             // invalid character
1164             m_string = originalString ? *originalString : url;
1165             invalidate();
1166             return;
1167         }
1168
1169         hostEnd = hostStart;
1170
1171         // IPV6 IP address
1172         if (url[hostEnd] == '[') {
1173             hostEnd++;
1174             while (isIPv6Char(url[hostEnd]))
1175                 hostEnd++;
1176             if (url[hostEnd] == ']')
1177                 hostEnd++;
1178             else {
1179                 // invalid character
1180                 m_string = originalString ? *originalString : url;
1181                 invalidate();
1182                 return;
1183             }
1184         } else {
1185             while (isHostnameChar(url[hostEnd]))
1186                 hostEnd++;
1187         }
1188         
1189         if (url[hostEnd] == ':') {
1190             portStart = portEnd = hostEnd + 1;
1191  
1192             // possible start of port
1193             portEnd = portStart;
1194             while (isASCIIDigit(url[portEnd]))
1195                 portEnd++;
1196         } else
1197             portStart = portEnd = hostEnd;
1198
1199         if (!isPathSegmentEndChar(url[portEnd])) {
1200             // invalid character
1201             m_string = originalString ? *originalString : url;
1202             invalidate();
1203             return;
1204         }
1205
1206         if (hostPortIsEmptyButCredentialsArePresent(hostStart, portEnd, url[userEnd])) {
1207             // in this circumstance, act as if there is an erroneous hostname containing an '@'
1208             userEnd = userStart;
1209             hostStart = userEnd;
1210         }
1211
1212         if (userStart == portEnd && !m_protocolIsInHTTPFamily && !isFile) {
1213             // No authority found, which means that this is not a net_path, but rather an abs_path whose first two
1214             // path segments are empty. For file, http and https only, an empty authority is allowed.
1215             userStart -= 2;
1216             userEnd = userStart;
1217             passwordStart = userEnd;
1218             passwordEnd = passwordStart;
1219             hostStart = passwordEnd;
1220             hostEnd = hostStart;
1221             portStart = hostEnd;
1222             portEnd = hostEnd;
1223         }
1224     } else {
1225         // the part after the scheme must be an opaque_part or an abs_path
1226         userEnd = userStart;
1227         passwordStart = passwordEnd = userEnd;
1228         hostStart = hostEnd = passwordEnd;
1229         portStart = portEnd = hostEnd;
1230     }
1231
1232     int pathStart = portEnd;
1233     int pathEnd = pathStart;
1234     while (url[pathEnd] && url[pathEnd] != '?' && url[pathEnd] != '#')
1235         pathEnd++;
1236
1237     int queryStart = pathEnd;
1238     int queryEnd = queryStart;
1239     if (url[queryStart] == '?') {
1240         while (url[queryEnd] && url[queryEnd] != '#')
1241             queryEnd++;
1242     }
1243
1244     int fragmentStart = queryEnd;
1245     int fragmentEnd = fragmentStart;
1246     if (url[fragmentStart] == '#') {
1247         fragmentStart++;
1248         fragmentEnd = fragmentStart;
1249         while (url[fragmentEnd])
1250             fragmentEnd++;
1251     }
1252
1253     // assemble it all, remembering the real ranges
1254
1255     Vector<char, 4096> buffer(fragmentEnd * 3 + 1);
1256
1257     char *p = buffer.data();
1258     const char *strPtr = url;
1259
1260     // copy in the scheme
1261     const char *schemeEndPtr = url + schemeEnd;
1262     while (strPtr < schemeEndPtr)
1263         *p++ = toASCIILower(*strPtr++);
1264     m_schemeEnd = p - buffer.data();
1265
1266     bool hostIsLocalHost = portEnd - userStart == 9
1267         && isLetterMatchIgnoringCase(url[userStart], 'l')
1268         && isLetterMatchIgnoringCase(url[userStart+1], 'o')
1269         && isLetterMatchIgnoringCase(url[userStart+2], 'c')
1270         && isLetterMatchIgnoringCase(url[userStart+3], 'a')
1271         && isLetterMatchIgnoringCase(url[userStart+4], 'l')
1272         && isLetterMatchIgnoringCase(url[userStart+5], 'h')
1273         && isLetterMatchIgnoringCase(url[userStart+6], 'o')
1274         && isLetterMatchIgnoringCase(url[userStart+7], 's')
1275         && isLetterMatchIgnoringCase(url[userStart+8], 't');
1276
1277     // File URLs need a host part unless it is just file:// or file://localhost
1278     bool degenerateFilePath = pathStart == pathEnd && (hostStart == hostEnd || hostIsLocalHost);
1279
1280     bool haveNonHostAuthorityPart = userStart != userEnd || passwordStart != passwordEnd || portStart != portEnd;
1281
1282     // add ":" after scheme
1283     *p++ = ':';
1284
1285     // if we have at least one authority part or a file URL - add "//" and authority
1286     if (isFile ? !degenerateFilePath : (haveNonHostAuthorityPart || hostStart != hostEnd)) {
1287         *p++ = '/';
1288         *p++ = '/';
1289
1290         m_userStart = p - buffer.data();
1291
1292         // copy in the user
1293         strPtr = url + userStart;
1294         const char* userEndPtr = url + userEnd;
1295         while (strPtr < userEndPtr)
1296             *p++ = *strPtr++;
1297         m_userEnd = p - buffer.data();
1298
1299         // copy in the password
1300         if (passwordEnd != passwordStart) {
1301             *p++ = ':';
1302             strPtr = url + passwordStart;
1303             const char* passwordEndPtr = url + passwordEnd;
1304             while (strPtr < passwordEndPtr)
1305                 *p++ = *strPtr++;
1306         }
1307         m_passwordEnd = p - buffer.data();
1308
1309         // If we had any user info, add "@"
1310         if (p - buffer.data() != m_userStart)
1311             *p++ = '@';
1312
1313         // copy in the host, except in the case of a file URL with authority="localhost"
1314         if (!(isFile && hostIsLocalHost && !haveNonHostAuthorityPart)) {
1315             strPtr = url + hostStart;
1316             const char* hostEndPtr = url + hostEnd;
1317             if (isCanonicalHostnameLowercaseForScheme(buffer.data(), m_schemeEnd)) {
1318                 while (strPtr < hostEndPtr)
1319                     *p++ = toASCIILower(*strPtr++);
1320             } else {
1321                 while (strPtr < hostEndPtr)
1322                     *p++ = *strPtr++;
1323             }
1324         }
1325         m_hostEnd = p - buffer.data();
1326
1327         // Copy in the port if the URL has one (and it's not default).
1328         if (hostEnd != portStart) {
1329             const char* portStr = url + portStart;
1330             size_t portLength = portEnd - portStart;
1331             if (portLength && !isDefaultPortForScheme(portStr, portLength, buffer.data(), m_schemeEnd)) {
1332                 *p++ = ':';
1333                 const char* portEndPtr = url + portEnd;
1334                 while (portStr < portEndPtr)
1335                     *p++ = *portStr++;
1336             }
1337         }
1338         m_portEnd = p - buffer.data();
1339     } else {
1340         if (isFile) {
1341             ASSERT(degenerateFilePath);
1342             *p++ = '/';
1343             *p++ = '/';
1344         }
1345         m_userStart = m_userEnd = m_passwordEnd = m_hostEnd = m_portEnd = p - buffer.data();
1346     }
1347
1348     // For canonicalization, ensure we have a '/' for no path.
1349     // Do this only for URL with protocol file, http or https.
1350     if ((m_protocolIsInHTTPFamily || isFile) && pathEnd == pathStart)
1351         *p++ = '/';
1352
1353     // add path, escaping bad characters
1354     if (!hierarchical)
1355         escapeAndAppendNonHierarchicalPart(p, url + pathStart, pathEnd - pathStart);
1356     else if (!hasSlashDotOrDotDot(url))
1357         appendEscapingBadChars(p, url + pathStart, pathEnd - pathStart);
1358     else {
1359         CharBuffer pathBuffer(pathEnd - pathStart + 1);
1360         size_t length = copyPathRemovingDots(pathBuffer.data(), url, pathStart, pathEnd);
1361         appendEscapingBadChars(p, pathBuffer.data(), length);
1362     }
1363
1364     m_pathEnd = p - buffer.data();
1365
1366     // Find the position after the last slash in the path, or
1367     // the position before the path if there are no slashes in it.
1368     int i;
1369     for (i = m_pathEnd; i > m_portEnd; --i) {
1370         if (buffer[i - 1] == '/')
1371             break;
1372     }
1373     m_pathAfterLastSlash = i;
1374
1375     // add query, escaping bad characters
1376     appendEscapingBadChars(p, url + queryStart, queryEnd - queryStart);
1377     m_queryEnd = p - buffer.data();
1378
1379     // add fragment, escaping bad characters
1380     if (fragmentEnd != queryEnd) {
1381         *p++ = '#';
1382         escapeAndAppendNonHierarchicalPart(p, url + fragmentStart, fragmentEnd - fragmentStart);
1383     }
1384     m_fragmentEnd = p - buffer.data();
1385
1386     ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
1387     ASSERT(buffer.size() > 0);
1388
1389     // If we didn't end up actually changing the original string and
1390     // it was already in a String, reuse it to avoid extra allocation.
1391     if (originalString && *originalString == buffer)
1392         m_string = *originalString;
1393     else
1394         m_string = String(buffer.data(), m_fragmentEnd);
1395
1396     m_isValid = true;
1397 }
1398
1399 bool equalIgnoringFragmentIdentifier(const KURL& a, const KURL& b)
1400 {
1401     if (a.m_queryEnd != b.m_queryEnd)
1402         return false;
1403     unsigned queryLength = a.m_queryEnd;
1404     for (unsigned i = 0; i < queryLength; ++i)
1405         if (a.string()[i] != b.string()[i])
1406             return false;
1407     return true;
1408 }
1409
1410 bool protocolHostAndPortAreEqual(const KURL& a, const KURL& b)
1411 {
1412     if (a.m_schemeEnd != b.m_schemeEnd)
1413         return false;
1414
1415     int hostStartA = a.hostStart();
1416     int hostLengthA = a.hostEnd() - hostStartA;
1417     int hostStartB = b.hostStart();
1418     int hostLengthB = b.hostEnd() - b.hostStart();
1419     if (hostLengthA != hostLengthB)
1420         return false;
1421
1422     // Check the scheme
1423     for (int i = 0; i < a.m_schemeEnd; ++i)
1424         if (a.string()[i] != b.string()[i])
1425             return false;
1426
1427     // And the host
1428     for (int i = 0; i < hostLengthA; ++i)
1429         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
1430             return false;
1431
1432     if (a.port() != b.port())
1433         return false;
1434
1435     return true;
1436 }
1437
1438 String encodeWithURLEscapeSequences(const String& notEncodedString)
1439 {
1440     CString asUTF8 = notEncodedString.utf8();
1441
1442     CharBuffer buffer(asUTF8.length() * 3 + 1);
1443     char* p = buffer.data();
1444
1445     const char* str = asUTF8.data();
1446     const char* strEnd = str + asUTF8.length();
1447     while (str < strEnd) {
1448         unsigned char c = *str++;
1449         if (isBadChar(c))
1450             appendEscapedChar(p, c);
1451         else
1452             *p++ = c;
1453     }
1454
1455     ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
1456
1457     return String(buffer.data(), p - buffer.data());
1458 }
1459
1460 // Appends the punycoded hostname identified by the given string and length to
1461 // the output buffer. The result will not be null terminated.
1462 static void appendEncodedHostname(UCharBuffer& buffer, const UChar* str, unsigned strLen)
1463 {
1464     // Needs to be big enough to hold an IDN-encoded name.
1465     // For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
1466     const unsigned hostnameBufferLength = 2048;
1467
1468     if (strLen > hostnameBufferLength || charactersAreAllASCII(str, strLen)) {
1469         buffer.append(str, strLen);
1470         return;
1471     }
1472
1473 #if USE(ICU_UNICODE)
1474     UChar hostnameBuffer[hostnameBufferLength];
1475     UErrorCode error = U_ZERO_ERROR;
1476     int32_t numCharactersConverted = uidna_IDNToASCII(str, strLen, hostnameBuffer,
1477         hostnameBufferLength, UIDNA_ALLOW_UNASSIGNED, 0, &error);
1478     if (error == U_ZERO_ERROR)
1479         buffer.append(hostnameBuffer, numCharactersConverted);
1480 #endif
1481 }
1482
1483 static void findHostnamesInMailToURL(const UChar* str, int strLen, Vector<pair<int, int> >& nameRanges)
1484 {
1485     // In a mailto: URL, host names come after a '@' character and end with a '>' or ',' or '?' or end of string character.
1486     // Skip quoted strings so that characters in them don't confuse us.
1487     // When we find a '?' character, we are past the part of the URL that contains host names.
1488
1489     nameRanges.clear();
1490
1491     int p = 0;
1492     while (1) {
1493         // Find start of host name or of quoted string.
1494         int hostnameOrStringStart = findFirstOf(str, strLen, p, "\"@?");
1495         if (hostnameOrStringStart == -1)
1496             return;
1497         UChar c = str[hostnameOrStringStart];
1498         p = hostnameOrStringStart + 1;
1499
1500         if (c == '?')
1501             return;
1502
1503         if (c == '@') {
1504             // Find end of host name.
1505             int hostnameStart = p;
1506             int hostnameEnd = findFirstOf(str, strLen, p, ">,?");
1507             bool done;
1508             if (hostnameEnd == -1) {
1509                 hostnameEnd = strLen;
1510                 done = true;
1511             } else {
1512                 p = hostnameEnd;
1513                 done = false;
1514             }
1515
1516             nameRanges.append(make_pair(hostnameStart, hostnameEnd));
1517
1518             if (done)
1519                 return;
1520         } else {
1521             // Skip quoted string.
1522             ASSERT(c == '"');
1523             while (1) {
1524                 int escapedCharacterOrStringEnd = findFirstOf(str, strLen, p, "\"\\");
1525                 if (escapedCharacterOrStringEnd == -1)
1526                     return;
1527
1528                 c = str[escapedCharacterOrStringEnd];
1529                 p = escapedCharacterOrStringEnd + 1;
1530
1531                 // If we are the end of the string, then break from the string loop back to the host name loop.
1532                 if (c == '"')
1533                     break;
1534
1535                 // Skip escaped character.
1536                 ASSERT(c == '\\');
1537                 if (p == strLen)
1538                     return;
1539
1540                 ++p;
1541             }
1542         }
1543     }
1544 }
1545
1546 static bool findHostnameInHierarchicalURL(const UChar* str, int strLen, int& startOffset, int& endOffset)
1547 {
1548     // Find the host name in a hierarchical URL.
1549     // It comes after a "://" sequence, with scheme characters preceding, and
1550     // this should be the first colon in the string.
1551     // It ends with the end of the string or a ":" or a path segment ending character.
1552     // If there is a "@" character, the host part is just the part after the "@".
1553     int separator = findFirstOf(str, strLen, 0, ":");
1554     if (separator == -1 || separator + 2 >= strLen ||
1555         str[separator + 1] != '/' || str[separator + 2] != '/')
1556         return false;
1557
1558     // Check that all characters before the :// are valid scheme characters.
1559     if (!isSchemeFirstChar(str[0]))
1560         return false;
1561     for (int i = 1; i < separator; ++i) {
1562         if (!isSchemeChar(str[i]))
1563             return false;
1564     }
1565
1566     // Start after the separator.
1567     int authorityStart = separator + 3;
1568
1569     // Find terminating character.
1570     int hostnameEnd = strLen;
1571     for (int i = authorityStart; i < strLen; ++i) {
1572         UChar c = str[i];
1573         if (c == ':' || (isPathSegmentEndChar(c) && c != 0)) {
1574             hostnameEnd = i;
1575             break;
1576         }
1577     }
1578
1579     // Find "@" for the start of the host name.
1580     int userInfoTerminator = findFirstOf(str, strLen, authorityStart, "@");
1581     int hostnameStart;
1582     if (userInfoTerminator == -1 || userInfoTerminator > hostnameEnd)
1583         hostnameStart = authorityStart;
1584     else
1585         hostnameStart = userInfoTerminator + 1;
1586
1587     startOffset = hostnameStart;
1588     endOffset = hostnameEnd;
1589     return true;
1590 }
1591
1592 // Converts all hostnames found in the given input to punycode, preserving the
1593 // rest of the URL unchanged. The output will NOT be null-terminated.
1594 static void encodeHostnames(const String& str, UCharBuffer& output)
1595 {
1596     output.clear();
1597
1598     if (protocolIs(str, "mailto")) {
1599         Vector<pair<int, int> > hostnameRanges;
1600         findHostnamesInMailToURL(str.characters(), str.length(), hostnameRanges);
1601         int n = hostnameRanges.size();
1602         int p = 0;
1603         for (int i = 0; i < n; ++i) {
1604             const pair<int, int>& r = hostnameRanges[i];
1605             output.append(&str.characters()[p], r.first - p);
1606             appendEncodedHostname(output, &str.characters()[r.first], r.second - r.first);
1607             p = r.second;
1608         }
1609         // This will copy either everything after the last hostname, or the
1610         // whole thing if there is no hostname.
1611         output.append(&str.characters()[p], str.length() - p);
1612     } else {
1613         int hostStart, hostEnd;
1614         if (findHostnameInHierarchicalURL(str.characters(), str.length(), hostStart, hostEnd)) {
1615             output.append(str.characters(), hostStart); // Before hostname.
1616             appendEncodedHostname(output, &str.characters()[hostStart], hostEnd - hostStart);
1617             output.append(&str.characters()[hostEnd], str.length() - hostEnd); // After hostname.
1618         } else {
1619             // No hostname to encode, return the input.
1620             output.append(str.characters(), str.length());
1621         }
1622     }
1623 }
1624
1625 static void encodeRelativeString(const String& rel, const TextEncoding& encoding, CharBuffer& output)
1626 {
1627     UCharBuffer s;
1628     encodeHostnames(rel, s);
1629
1630     TextEncoding pathEncoding(UTF8Encoding()); // Path is always encoded as UTF-8; other parts may depend on the scheme.
1631
1632     int pathEnd = -1;
1633     if (encoding != pathEncoding && encoding.isValid() && !protocolIs(rel, "mailto") && !protocolIs(rel, "data") && !protocolIsJavaScript(rel)) {
1634         // Find the first instance of either # or ?, keep pathEnd at -1 otherwise.
1635         pathEnd = findFirstOf(s.data(), s.size(), 0, "#?");
1636     }
1637
1638     if (pathEnd == -1) {
1639         CString decoded = pathEncoding.encode(s.data(), s.size(), URLEncodedEntitiesForUnencodables);
1640         output.resize(decoded.length());
1641         memcpy(output.data(), decoded.data(), decoded.length());
1642     } else {
1643         CString pathDecoded = pathEncoding.encode(s.data(), pathEnd, URLEncodedEntitiesForUnencodables);
1644         // Unencodable characters in URLs are represented by converting
1645         // them to XML entities and escaping non-alphanumeric characters.
1646         CString otherDecoded = encoding.encode(s.data() + pathEnd, s.size() - pathEnd, URLEncodedEntitiesForUnencodables);
1647
1648         output.resize(pathDecoded.length() + otherDecoded.length());
1649         memcpy(output.data(), pathDecoded.data(), pathDecoded.length());
1650         memcpy(output.data() + pathDecoded.length(), otherDecoded.data(), otherDecoded.length());
1651     }
1652     output.append('\0'); // null-terminate the output.
1653 }
1654
1655 static String substituteBackslashes(const String& string)
1656 {
1657     size_t questionPos = string.find('?');
1658     size_t hashPos = string.find('#');
1659     unsigned pathEnd;
1660
1661     if (hashPos != notFound && (questionPos == notFound || questionPos > hashPos))
1662         pathEnd = hashPos;
1663     else if (questionPos != notFound)
1664         pathEnd = questionPos;
1665     else
1666         pathEnd = string.length();
1667
1668     return string.left(pathEnd).replace('\\','/') + string.substring(pathEnd);
1669 }
1670
1671 bool KURL::isHierarchical() const
1672 {
1673     if (!m_isValid)
1674         return false;
1675     ASSERT(m_string[m_schemeEnd] == ':');
1676     return m_string[m_schemeEnd + 1] == '/';
1677 }
1678
1679 void KURL::copyToBuffer(CharBuffer& buffer) const
1680 {
1681     // FIXME: This throws away the high bytes of all the characters in the string!
1682     // That's fine for a valid URL, which is all ASCII, but not for invalid URLs.
1683     buffer.resize(m_string.length());
1684     copyASCII(m_string, buffer.data());
1685 }
1686
1687 bool protocolIs(const String& url, const char* protocol)
1688 {
1689     // Do the comparison without making a new string object.
1690     assertProtocolIsGood(protocol);
1691     for (int i = 0; ; ++i) {
1692         if (!protocol[i])
1693             return url[i] == ':';
1694         if (!isLetterMatchIgnoringCase(url[i], protocol[i]))
1695             return false;
1696     }
1697 }
1698
1699 bool isValidProtocol(const String& protocol)
1700 {
1701     // RFC3986: ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
1702     if (protocol.isEmpty())
1703         return false;
1704     if (!isSchemeFirstChar(protocol[0]))
1705         return false;
1706     unsigned protocolLength = protocol.length();
1707     for (unsigned i = 1; i < protocolLength; i++) {
1708         if (!isSchemeChar(protocol[i]))
1709             return false;
1710     }
1711     return true;
1712 }
1713
1714 #ifndef NDEBUG
1715 void KURL::print() const
1716 {
1717     printf("%s\n", m_string.utf8().data());
1718 }
1719 #endif
1720
1721 #endif // !USE(GOOGLEURL) && !USE(WTFURL)
1722
1723 String KURL::strippedForUseAsReferrer() const
1724 {
1725     KURL referrer(*this);
1726     referrer.setUser(String());
1727     referrer.setPass(String());
1728     referrer.removeFragmentIdentifier();
1729     return referrer.string();
1730 }
1731
1732 bool KURL::isLocalFile() const
1733 {
1734     // Including feed here might be a bad idea since drag and drop uses this check
1735     // and including feed would allow feeds to potentially let someone's blog
1736     // read the contents of the clipboard on a drag, even without a drop.
1737     // Likewise with using the FrameLoader::shouldTreatURLAsLocal() function.
1738     return protocolIs("file");
1739 }
1740
1741 bool protocolIsJavaScript(const String& url)
1742 {
1743     return protocolIs(url, "javascript");
1744 }
1745
1746 const KURL& blankURL()
1747 {
1748     DEFINE_STATIC_LOCAL(KURL, staticBlankURL, (ParsedURLString, "about:blank"));
1749     return staticBlankURL;
1750 }
1751
1752 bool KURL::isBlankURL() const
1753 {
1754     return protocolIs("about");
1755 }
1756
1757 bool isDefaultPortForProtocol(unsigned short port, const String& protocol)
1758 {
1759     if (protocol.isEmpty())
1760         return false;
1761
1762     typedef HashMap<String, unsigned, CaseFoldingHash> DefaultPortsMap;
1763     DEFINE_STATIC_LOCAL(DefaultPortsMap, defaultPorts, ());
1764     if (defaultPorts.isEmpty()) {
1765         defaultPorts.set("http", 80);
1766         defaultPorts.set("https", 443);
1767         defaultPorts.set("ftp", 21);
1768         defaultPorts.set("ftps", 990);
1769     }
1770     return defaultPorts.get(protocol) == port;
1771 }
1772
1773 bool portAllowed(const KURL& url)
1774 {
1775     unsigned short port = url.port();
1776
1777     // Since most URLs don't have a port, return early for the "no port" case.
1778     if (!port)
1779         return true;
1780
1781     // This blocked port list matches the port blocking that Mozilla implements.
1782     // See http://www.mozilla.org/projects/netlib/PortBanning.html for more information.
1783     static const unsigned short blockedPortList[] = {
1784         1,    // tcpmux
1785         7,    // echo
1786         9,    // discard
1787         11,   // systat
1788         13,   // daytime
1789         15,   // netstat
1790         17,   // qotd
1791         19,   // chargen
1792         20,   // FTP-data
1793         21,   // FTP-control
1794         22,   // SSH
1795         23,   // telnet
1796         25,   // SMTP
1797         37,   // time
1798         42,   // name
1799         43,   // nicname
1800         53,   // domain
1801         77,   // priv-rjs
1802         79,   // finger
1803         87,   // ttylink
1804         95,   // supdup
1805         101,  // hostriame
1806         102,  // iso-tsap
1807         103,  // gppitnp
1808         104,  // acr-nema
1809         109,  // POP2
1810         110,  // POP3
1811         111,  // sunrpc
1812         113,  // auth
1813         115,  // SFTP
1814         117,  // uucp-path
1815         119,  // nntp
1816         123,  // NTP
1817         135,  // loc-srv / epmap
1818         139,  // netbios
1819         143,  // IMAP2
1820         179,  // BGP
1821         389,  // LDAP
1822         465,  // SMTP+SSL
1823         512,  // print / exec
1824         513,  // login
1825         514,  // shell
1826         515,  // printer
1827         526,  // tempo
1828         530,  // courier
1829         531,  // Chat
1830         532,  // netnews
1831         540,  // UUCP
1832         556,  // remotefs
1833         563,  // NNTP+SSL
1834         587,  // ESMTP
1835         601,  // syslog-conn
1836         636,  // LDAP+SSL
1837         993,  // IMAP+SSL
1838         995,  // POP3+SSL
1839         2049, // NFS
1840         3659, // apple-sasl / PasswordServer [Apple addition]
1841         4045, // lockd
1842         6000, // X11
1843         6665, // Alternate IRC [Apple addition]
1844         6666, // Alternate IRC [Apple addition]
1845         6667, // Standard IRC [Apple addition]
1846         6668, // Alternate IRC [Apple addition]
1847         6669, // Alternate IRC [Apple addition]
1848         invalidPortNumber, // Used to block all invalid port numbers
1849     };
1850     const unsigned short* const blockedPortListEnd = blockedPortList + WTF_ARRAY_LENGTH(blockedPortList);
1851
1852 #ifndef NDEBUG
1853     // The port list must be sorted for binary_search to work.
1854     static bool checkedPortList = false;
1855     if (!checkedPortList) {
1856         for (const unsigned short* p = blockedPortList; p != blockedPortListEnd - 1; ++p)
1857             ASSERT(*p < *(p + 1));
1858         checkedPortList = true;
1859     }
1860 #endif
1861
1862     // If the port is not in the blocked port list, allow it.
1863     if (!binary_search(blockedPortList, blockedPortListEnd, port))
1864         return true;
1865
1866     // Allow ports 21 and 22 for FTP URLs, as Mozilla does.
1867     if ((port == 21 || port == 22) && url.protocolIs("ftp"))
1868         return true;
1869
1870     // Allow any port number in a file URL, since the port number is ignored.
1871     if (url.protocolIs("file"))
1872         return true;
1873
1874 #if PLATFORM(BLACKBERRY)
1875     if (url.protocolIs("local"))
1876         return true;
1877 #endif
1878
1879     return false;
1880 }
1881
1882 String mimeTypeFromDataURL(const String& url)
1883 {
1884     ASSERT(protocolIs(url, "data"));
1885     size_t index = url.find(';');
1886     if (index == notFound)
1887         index = url.find(',');
1888     if (index != notFound) {
1889         if (index > 5)
1890             return url.substring(5, index - 5);
1891         return "text/plain"; // Data URLs with no MIME type are considered text/plain.
1892     }
1893     return "";
1894 }
1895
1896 String mimeTypeFromURL(const KURL& url)
1897 {
1898     String decodedPath = decodeURLEscapeSequences(url.path());
1899     String extension = decodedPath.substring(decodedPath.reverseFind('.') + 1);
1900
1901     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
1902     return MIMETypeRegistry::getMIMETypeForExtension(extension);
1903 }
1904
1905 void KURL::reportMemoryUsage(MemoryObjectInfo* memoryObjectInfo) const
1906 {
1907     MemoryClassInfo info(memoryObjectInfo, this);
1908 #if USE(GOOGLEURL)
1909     info.addMember(m_url, "url");
1910 #elif USE(WTFURL)
1911     info.addMember(m_urlImpl, "urlImpl");
1912 #else // !USE(GOOGLEURL)
1913     info.addMember(m_string, "string");
1914 #endif
1915 }
1916
1917 bool KURL::isSafeToSendToAnotherThread() const
1918 {
1919 #if USE(GOOGLEURL)
1920     return m_url.isSafeToSendToAnotherThread();
1921 #elif USE(WTFURL)
1922     return m_urlImpl->isSafeToSendToAnotherThread();
1923 #else // !USE(GOOGLEURL)
1924     return m_string.isSafeToSendToAnotherThread();
1925 #endif
1926 }
1927
1928 String KURL::elidedString() const
1929 {
1930     if (string().length() <= 1024)
1931         return string();
1932
1933     return string().left(511) + "..." + string().right(510);
1934 }
1935
1936 }