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