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