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