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