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