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