Unreviewed clean-up after r219323
[WebKit.git] / Source / WebCore / platform / URL.cpp
1 /*
2  * Copyright (C) 2004, 2007-2008, 2011-2013, 2015-2016 Apple Inc. All rights reserved.
3  * Copyright (C) 2012 Research In Motion Limited. All rights reserved.
4  *
5  * Redistribution and use in source and binary forms, with or without
6  * modification, are permitted provided that the following conditions
7  * are met:
8  * 1. Redistributions of source code must retain the above copyright
9  *    notice, this list of conditions and the following disclaimer.
10  * 2. Redistributions in binary form must reproduce the above copyright
11  *    notice, this list of conditions and the following disclaimer in the
12  *    documentation and/or other materials provided with the distribution.
13  *
14  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY
15  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
16  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
17  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR
18  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
19  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
20  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
21  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
22  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
24  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 
25  */
26
27 #include "config.h"
28 #include "URL.h"
29
30 #include "DecodeEscapeSequences.h"
31 #include "MIMETypeRegistry.h"
32 #include "TextEncoding.h"
33 #include "URLParser.h"
34 #include <stdio.h>
35 #include <unicode/uidna.h>
36 #include <wtf/HashMap.h>
37 #include <wtf/HexNumber.h>
38 #include <wtf/NeverDestroyed.h>
39 #include <wtf/StdLibExtras.h>
40 #include <wtf/UUID.h>
41 #include <wtf/text/CString.h>
42 #include <wtf/text/StringBuilder.h>
43 #include <wtf/text/StringHash.h>
44
45 // FIXME: This file makes too much use of the + operator on String.
46 // We either have to optimize that operator so it doesn't involve
47 // so many allocations, or change this to use StringBuffer instead.
48
49 using namespace WTF;
50
51 namespace WebCore {
52
53 typedef Vector<char, 512> CharBuffer;
54 typedef Vector<UChar, 512> UCharBuffer;
55
56 static const unsigned invalidPortNumber = 0xFFFF;
57
58 enum URLCharacterClasses {
59     // alpha 
60     SchemeFirstChar = 1 << 0,
61
62     // ( alpha | digit | "+" | "-" | "." )
63     SchemeChar = 1 << 1,
64
65     // mark        = "-" | "_" | "." | "!" | "~" | "*" | "'" | "(" | ")"
66     // unreserved  = alphanum | mark
67     // ( unreserved | escaped | ";" | ":" | "&" | "=" | "+" | "$" | "," )
68     UserInfoChar = 1 << 2,
69
70     // alnum | "." | "-" | "%"
71     // The above is what the specification says, but we are lenient to
72     // match existing practice and also allow:
73     // "_"
74     HostnameChar = 1 << 3,
75
76     // hexdigit | ":" | "%"
77     IPv6Char = 1 << 4,
78
79     // "#" | "?" | "/" | nul
80     PathSegmentEndChar = 1 << 5,
81
82     // not allowed in path
83     BadChar = 1 << 6,
84
85     // "\t" | "\n" | "\r"
86     TabNewline = 1 << 7
87 };
88
89 static const unsigned char characterClassTable[256] = {
90     /* 0 nul */ PathSegmentEndChar,    /* 1 soh */ BadChar,
91     /* 2 stx */ BadChar,    /* 3 etx */ BadChar,
92     /* 4 eot */ BadChar,    /* 5 enq */ BadChar,    /* 6 ack */ BadChar,    /* 7 bel */ BadChar,
93     /* 8 bs */ BadChar,     /* 9 ht */ BadChar | TabNewline,                /* 10 nl */ BadChar | TabNewline,
94     /* 11 vt */ BadChar,    /* 12 np */ BadChar,    /* 13 cr */ BadChar | TabNewline,
95     /* 14 so */ BadChar,    /* 15 si */ BadChar,
96     /* 16 dle */ BadChar,   /* 17 dc1 */ BadChar,   /* 18 dc2 */ BadChar,   /* 19 dc3 */ BadChar,
97     /* 20 dc4 */ BadChar,   /* 21 nak */ BadChar,   /* 22 syn */ BadChar,   /* 23 etb */ BadChar,
98     /* 24 can */ BadChar,   /* 25 em */ BadChar,    /* 26 sub */ BadChar,   /* 27 esc */ BadChar,
99     /* 28 fs */ BadChar,    /* 29 gs */ BadChar,    /* 30 rs */ BadChar,    /* 31 us */ BadChar,
100     /* 32 sp */ BadChar,    /* 33  ! */ UserInfoChar,
101     /* 34  " */ BadChar,    /* 35  # */ PathSegmentEndChar | BadChar,
102     /* 36  $ */ UserInfoChar,    /* 37  % */ UserInfoChar | HostnameChar | IPv6Char | BadChar,
103     /* 38  & */ UserInfoChar,    /* 39  ' */ UserInfoChar,
104     /* 40  ( */ UserInfoChar,    /* 41  ) */ UserInfoChar,
105     /* 42  * */ UserInfoChar,    /* 43  + */ SchemeChar | UserInfoChar,
106     /* 44  , */ UserInfoChar,
107     /* 45  - */ SchemeChar | UserInfoChar | HostnameChar,
108     /* 46  . */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
109     /* 47  / */ PathSegmentEndChar,
110     /* 48  0 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
111     /* 49  1 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,    
112     /* 50  2 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
113     /* 51  3 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
114     /* 52  4 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
115     /* 53  5 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
116     /* 54  6 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
117     /* 55  7 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
118     /* 56  8 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
119     /* 57  9 */ SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
120     /* 58  : */ UserInfoChar | IPv6Char,    /* 59  ; */ UserInfoChar,
121     /* 60  < */ BadChar,    /* 61  = */ UserInfoChar,
122     /* 62  > */ BadChar,    /* 63  ? */ PathSegmentEndChar | BadChar,
123     /* 64  @ */ 0,
124     /* 65  A */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,    
125     /* 66  B */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
126     /* 67  C */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
127     /* 68  D */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
128     /* 69  E */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
129     /* 70  F */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
130     /* 71  G */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
131     /* 72  H */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
132     /* 73  I */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
133     /* 74  J */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
134     /* 75  K */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
135     /* 76  L */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
136     /* 77  M */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
137     /* 78  N */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
138     /* 79  O */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
139     /* 80  P */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
140     /* 81  Q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
141     /* 82  R */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
142     /* 83  S */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
143     /* 84  T */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
144     /* 85  U */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
145     /* 86  V */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
146     /* 87  W */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
147     /* 88  X */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
148     /* 89  Y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
149     /* 90  Z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
150     /* 91  [ */ 0,
151     /* 92  \ */ 0,    /* 93  ] */ 0,
152     /* 94  ^ */ 0,
153     /* 95  _ */ UserInfoChar | HostnameChar,
154     /* 96  ` */ 0,
155     /* 97  a */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
156     /* 98  b */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
157     /* 99  c */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
158     /* 100  d */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
159     /* 101  e */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char,
160     /* 102  f */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar | IPv6Char, 
161     /* 103  g */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
162     /* 104  h */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
163     /* 105  i */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
164     /* 106  j */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
165     /* 107  k */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
166     /* 108  l */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
167     /* 109  m */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
168     /* 110  n */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
169     /* 111  o */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
170     /* 112  p */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
171     /* 113  q */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
172     /* 114  r */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
173     /* 115  s */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
174     /* 116  t */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
175     /* 117  u */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
176     /* 118  v */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
177     /* 119  w */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
178     /* 120  x */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
179     /* 121  y */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar,
180     /* 122  z */ SchemeFirstChar | SchemeChar | UserInfoChar | HostnameChar, 
181     /* 123  { */ 0,
182     /* 124  | */ 0,   /* 125  } */ 0,   /* 126  ~ */ UserInfoChar,   /* 127 del */ BadChar,
183     /* 128 */ BadChar, /* 129 */ BadChar, /* 130 */ BadChar, /* 131 */ BadChar,
184     /* 132 */ BadChar, /* 133 */ BadChar, /* 134 */ BadChar, /* 135 */ BadChar,
185     /* 136 */ BadChar, /* 137 */ BadChar, /* 138 */ BadChar, /* 139 */ BadChar,
186     /* 140 */ BadChar, /* 141 */ BadChar, /* 142 */ BadChar, /* 143 */ BadChar,
187     /* 144 */ BadChar, /* 145 */ BadChar, /* 146 */ BadChar, /* 147 */ BadChar,
188     /* 148 */ BadChar, /* 149 */ BadChar, /* 150 */ BadChar, /* 151 */ BadChar,
189     /* 152 */ BadChar, /* 153 */ BadChar, /* 154 */ BadChar, /* 155 */ BadChar,
190     /* 156 */ BadChar, /* 157 */ BadChar, /* 158 */ BadChar, /* 159 */ BadChar,
191     /* 160 */ BadChar, /* 161 */ BadChar, /* 162 */ BadChar, /* 163 */ BadChar,
192     /* 164 */ BadChar, /* 165 */ BadChar, /* 166 */ BadChar, /* 167 */ BadChar,
193     /* 168 */ BadChar, /* 169 */ BadChar, /* 170 */ BadChar, /* 171 */ BadChar,
194     /* 172 */ BadChar, /* 173 */ BadChar, /* 174 */ BadChar, /* 175 */ BadChar,
195     /* 176 */ BadChar, /* 177 */ BadChar, /* 178 */ BadChar, /* 179 */ BadChar,
196     /* 180 */ BadChar, /* 181 */ BadChar, /* 182 */ BadChar, /* 183 */ BadChar,
197     /* 184 */ BadChar, /* 185 */ BadChar, /* 186 */ BadChar, /* 187 */ BadChar,
198     /* 188 */ BadChar, /* 189 */ BadChar, /* 190 */ BadChar, /* 191 */ BadChar,
199     /* 192 */ BadChar, /* 193 */ BadChar, /* 194 */ BadChar, /* 195 */ BadChar,
200     /* 196 */ BadChar, /* 197 */ BadChar, /* 198 */ BadChar, /* 199 */ BadChar,
201     /* 200 */ BadChar, /* 201 */ BadChar, /* 202 */ BadChar, /* 203 */ BadChar,
202     /* 204 */ BadChar, /* 205 */ BadChar, /* 206 */ BadChar, /* 207 */ BadChar,
203     /* 208 */ BadChar, /* 209 */ BadChar, /* 210 */ BadChar, /* 211 */ BadChar,
204     /* 212 */ BadChar, /* 213 */ BadChar, /* 214 */ BadChar, /* 215 */ BadChar,
205     /* 216 */ BadChar, /* 217 */ BadChar, /* 218 */ BadChar, /* 219 */ BadChar,
206     /* 220 */ BadChar, /* 221 */ BadChar, /* 222 */ BadChar, /* 223 */ BadChar,
207     /* 224 */ BadChar, /* 225 */ BadChar, /* 226 */ BadChar, /* 227 */ BadChar,
208     /* 228 */ BadChar, /* 229 */ BadChar, /* 230 */ BadChar, /* 231 */ BadChar,
209     /* 232 */ BadChar, /* 233 */ BadChar, /* 234 */ BadChar, /* 235 */ BadChar,
210     /* 236 */ BadChar, /* 237 */ BadChar, /* 238 */ BadChar, /* 239 */ BadChar,
211     /* 240 */ BadChar, /* 241 */ BadChar, /* 242 */ BadChar, /* 243 */ BadChar,
212     /* 244 */ BadChar, /* 245 */ BadChar, /* 246 */ BadChar, /* 247 */ BadChar,
213     /* 248 */ BadChar, /* 249 */ BadChar, /* 250 */ BadChar, /* 251 */ BadChar,
214     /* 252 */ BadChar, /* 253 */ BadChar, /* 254 */ BadChar, /* 255 */ BadChar
215 };
216
217 enum PercentEncodeCharacterClass {
218     // Class names match the URL Standard; each class is a superset of the previous one.
219     PercentEncodeSimple = 255,
220     PercentEncodeDefault = 127,
221     PercentEncodePassword = 63,
222     PercentEncodeUsername = 31,
223 };
224
225 static const unsigned char percentEncodeClassTable[256] = {
226     /* 0 nul */ PercentEncodeSimple,    /* 1 soh */ PercentEncodeSimple,    /* 2 stx */ PercentEncodeSimple,    /* 3 etx */ PercentEncodeSimple,
227     /* 4 eot */ PercentEncodeSimple,    /* 5 enq */ PercentEncodeSimple,    /* 6 ack */ PercentEncodeSimple,    /* 7 bel */ PercentEncodeSimple,
228     /* 8 bs */ PercentEncodeSimple,     /* 9 ht */ PercentEncodeSimple,     /* 10 nl */ PercentEncodeSimple,    /* 11 vt */ PercentEncodeSimple,
229     /* 12 np */ PercentEncodeSimple,    /* 13 cr */ PercentEncodeSimple,    /* 14 so */ PercentEncodeSimple,    /* 15 si */ PercentEncodeSimple,
230     /* 16 dle */ PercentEncodeSimple,   /* 17 dc1 */ PercentEncodeSimple,   /* 18 dc2 */ PercentEncodeSimple,   /* 19 dc3 */ PercentEncodeSimple,
231     /* 20 dc4 */ PercentEncodeSimple,   /* 21 nak */ PercentEncodeSimple,   /* 22 syn */ PercentEncodeSimple,   /* 23 etb */ PercentEncodeSimple,
232     /* 24 can */ PercentEncodeSimple,   /* 25 em */ PercentEncodeSimple,    /* 26 sub */ PercentEncodeSimple,   /* 27 esc */ PercentEncodeSimple,
233     /* 28 fs */ PercentEncodeSimple,    /* 29 gs */ PercentEncodeSimple,    /* 30 rs */ PercentEncodeSimple,    /* 31 us */ PercentEncodeSimple,
234     /* 32 sp */ PercentEncodeDefault,
235     /* 33  ! */ 0,
236     /* 34  " */ PercentEncodeDefault,
237     /* 35  # */ PercentEncodeDefault,
238     /* 36  $ */ 0,
239     /* 37  % */ 0,
240     /* 38  & */ 0,
241     /* 39  ' */ 0,
242     /* 40  ( */ 0,
243     /* 41  ) */ 0,
244     /* 42  * */ 0,
245     /* 43  + */ 0,
246     /* 44  , */ 0,
247     /* 45  - */ 0,
248     /* 46  . */ 0,
249     /* 47  / */ PercentEncodePassword,
250     /* 48  0 */ 0,    /* 49  1 */ 0,    /* 50  2 */ 0,    /* 51  3 */ 0,
251     /* 52  4 */ 0,    /* 53  5 */ 0,    /* 54  6 */ 0,    /* 55  7 */ 0,
252     /* 56  8 */ 0,    /* 57  9 */ 0,
253     /* 58  : */ PercentEncodeUsername,
254     /* 59  ; */ 0,
255     /* 60  < */ PercentEncodeDefault,
256     /* 61  = */ 0,
257     /* 62  > */ PercentEncodeDefault,
258     /* 63  ? */ PercentEncodeDefault,
259     /* 64  @ */ PercentEncodePassword,
260     /* 65  A */ 0,    /* 66  B */ 0,    /* 67  C */ 0,    /* 68  D */ 0,
261     /* 69  E */ 0,    /* 70  F */ 0,    /* 71  G */ 0,    /* 72  H */ 0,
262     /* 73  I */ 0,    /* 74  J */ 0,    /* 75  K */ 0,    /* 76  L */ 0,
263     /* 77  M */ 0,    /* 78  N */ 0,    /* 79  O */ 0,    /* 80  P */ 0,
264     /* 81  Q */ 0,    /* 82  R */ 0,    /* 83  S */ 0,    /* 84  T */ 0,
265     /* 85  U */ 0,    /* 86  V */ 0,    /* 87  W */ 0,    /* 88  X */ 0,
266     /* 89  Y */ 0,    /* 90  Z */ 0,
267     /* 91  [ */ 0,
268     /* 92  \ */ PercentEncodePassword,
269     /* 93  ] */ 0,
270     /* 94  ^ */ 0,
271     /* 95  _ */ 0,
272     /* 96  ` */ PercentEncodeDefault,
273     /* 97  a */ 0,    /* 98  b */ 0,    /* 99  c */ 0,    /* 100  d */ 0,
274     /* 101  e */ 0,    /* 102  f */ 0,    /* 103  g */ 0,    /* 104  h */ 0,
275     /* 105  i */ 0,    /* 106  j */ 0,    /* 107  k */ 0,    /* 108  l */ 0,
276     /* 109  m */ 0,    /* 110  n */ 0,    /* 111  o */ 0,    /* 112  p */ 0,
277     /* 113  q */ 0,    /* 114  r */ 0,    /* 115  s */ 0,    /* 116  t */ 0,
278     /* 117  u */ 0,    /* 118  v */ 0,    /* 119  w */ 0,    /* 120  x */ 0,
279     /* 121  y */ 0,    /* 122  z */ 0,
280     /* 123  { */ 0,
281     /* 124  | */ 0,
282     /* 125  } */ 0,
283     /* 126  ~ */ 0,
284     /* 127 del */ PercentEncodeSimple,
285     /* 128 */ PercentEncodeSimple, /* 129 */ PercentEncodeSimple, /* 130 */ PercentEncodeSimple, /* 131 */ PercentEncodeSimple,
286     /* 132 */ PercentEncodeSimple, /* 133 */ PercentEncodeSimple, /* 134 */ PercentEncodeSimple, /* 135 */ PercentEncodeSimple,
287     /* 136 */ PercentEncodeSimple, /* 137 */ PercentEncodeSimple, /* 138 */ PercentEncodeSimple, /* 139 */ PercentEncodeSimple,
288     /* 140 */ PercentEncodeSimple, /* 141 */ PercentEncodeSimple, /* 142 */ PercentEncodeSimple, /* 143 */ PercentEncodeSimple,
289     /* 144 */ PercentEncodeSimple, /* 145 */ PercentEncodeSimple, /* 146 */ PercentEncodeSimple, /* 147 */ PercentEncodeSimple,
290     /* 148 */ PercentEncodeSimple, /* 149 */ PercentEncodeSimple, /* 150 */ PercentEncodeSimple, /* 151 */ PercentEncodeSimple,
291     /* 152 */ PercentEncodeSimple, /* 153 */ PercentEncodeSimple, /* 154 */ PercentEncodeSimple, /* 155 */ PercentEncodeSimple,
292     /* 156 */ PercentEncodeSimple, /* 157 */ PercentEncodeSimple, /* 158 */ PercentEncodeSimple, /* 159 */ PercentEncodeSimple,
293     /* 160 */ PercentEncodeSimple, /* 161 */ PercentEncodeSimple, /* 162 */ PercentEncodeSimple, /* 163 */ PercentEncodeSimple,
294     /* 164 */ PercentEncodeSimple, /* 165 */ PercentEncodeSimple, /* 166 */ PercentEncodeSimple, /* 167 */ PercentEncodeSimple,
295     /* 168 */ PercentEncodeSimple, /* 169 */ PercentEncodeSimple, /* 170 */ PercentEncodeSimple, /* 171 */ PercentEncodeSimple,
296     /* 172 */ PercentEncodeSimple, /* 173 */ PercentEncodeSimple, /* 174 */ PercentEncodeSimple, /* 175 */ PercentEncodeSimple,
297     /* 176 */ PercentEncodeSimple, /* 177 */ PercentEncodeSimple, /* 178 */ PercentEncodeSimple, /* 179 */ PercentEncodeSimple,
298     /* 180 */ PercentEncodeSimple, /* 181 */ PercentEncodeSimple, /* 182 */ PercentEncodeSimple, /* 183 */ PercentEncodeSimple,
299     /* 184 */ PercentEncodeSimple, /* 185 */ PercentEncodeSimple, /* 186 */ PercentEncodeSimple, /* 187 */ PercentEncodeSimple,
300     /* 188 */ PercentEncodeSimple, /* 189 */ PercentEncodeSimple, /* 190 */ PercentEncodeSimple, /* 191 */ PercentEncodeSimple,
301     /* 192 */ PercentEncodeSimple, /* 193 */ PercentEncodeSimple, /* 194 */ PercentEncodeSimple, /* 195 */ PercentEncodeSimple,
302     /* 196 */ PercentEncodeSimple, /* 197 */ PercentEncodeSimple, /* 198 */ PercentEncodeSimple, /* 199 */ PercentEncodeSimple,
303     /* 200 */ PercentEncodeSimple, /* 201 */ PercentEncodeSimple, /* 202 */ PercentEncodeSimple, /* 203 */ PercentEncodeSimple,
304     /* 204 */ PercentEncodeSimple, /* 205 */ PercentEncodeSimple, /* 206 */ PercentEncodeSimple, /* 207 */ PercentEncodeSimple,
305     /* 208 */ PercentEncodeSimple, /* 209 */ PercentEncodeSimple, /* 210 */ PercentEncodeSimple, /* 211 */ PercentEncodeSimple,
306     /* 212 */ PercentEncodeSimple, /* 213 */ PercentEncodeSimple, /* 214 */ PercentEncodeSimple, /* 215 */ PercentEncodeSimple,
307     /* 216 */ PercentEncodeSimple, /* 217 */ PercentEncodeSimple, /* 218 */ PercentEncodeSimple, /* 219 */ PercentEncodeSimple,
308     /* 220 */ PercentEncodeSimple, /* 221 */ PercentEncodeSimple, /* 222 */ PercentEncodeSimple, /* 223 */ PercentEncodeSimple,
309     /* 224 */ PercentEncodeSimple, /* 225 */ PercentEncodeSimple, /* 226 */ PercentEncodeSimple, /* 227 */ PercentEncodeSimple,
310     /* 228 */ PercentEncodeSimple, /* 229 */ PercentEncodeSimple, /* 230 */ PercentEncodeSimple, /* 231 */ PercentEncodeSimple,
311     /* 232 */ PercentEncodeSimple, /* 233 */ PercentEncodeSimple, /* 234 */ PercentEncodeSimple, /* 235 */ PercentEncodeSimple,
312     /* 236 */ PercentEncodeSimple, /* 237 */ PercentEncodeSimple, /* 238 */ PercentEncodeSimple, /* 239 */ PercentEncodeSimple,
313     /* 240 */ PercentEncodeSimple, /* 241 */ PercentEncodeSimple, /* 242 */ PercentEncodeSimple, /* 243 */ PercentEncodeSimple,
314     /* 244 */ PercentEncodeSimple, /* 245 */ PercentEncodeSimple, /* 246 */ PercentEncodeSimple, /* 247 */ PercentEncodeSimple,
315     /* 248 */ PercentEncodeSimple, /* 249 */ PercentEncodeSimple, /* 250 */ PercentEncodeSimple, /* 251 */ PercentEncodeSimple,
316     /* 252 */ PercentEncodeSimple, /* 253 */ PercentEncodeSimple, /* 254 */ PercentEncodeSimple, /* 255 */ PercentEncodeSimple
317 };
318
319 static inline bool isSchemeFirstChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeFirstChar); }
320 static inline bool isSchemeChar(UChar c) { return c <= 0xff && (characterClassTable[c] & SchemeChar); }
321 static inline bool isBadChar(unsigned char c) { return characterClassTable[c] & BadChar; }
322 static inline bool isTabNewline(UChar c) { return c <= 0xff && (characterClassTable[c] & TabNewline); }
323
324 String encodeWithURLEscapeSequences(const String& notEncodedString, PercentEncodeCharacterClass whatToEncode);
325
326 // Copies the source to the destination, assuming all the source characters are
327 // ASCII. The destination buffer must be large enough. Null characters are allowed
328 // in the source string, and no attempt is made to null-terminate the result.
329 static void copyASCII(const String& string, char* dest)
330 {
331     if (string.isEmpty())
332         return;
333
334     if (string.is8Bit())
335         memcpy(dest, string.characters8(), string.length());
336     else {
337         const UChar* src = string.characters16();
338         size_t length = string.length();
339         for (size_t i = 0; i < length; i++)
340             dest[i] = static_cast<char>(src[i]);
341     }
342 }
343
344 void URL::invalidate()
345 {
346     m_isValid = false;
347     m_protocolIsInHTTPFamily = false;
348     m_cannotBeABaseURL = false;
349     m_schemeEnd = 0;
350     m_userStart = 0;
351     m_userEnd = 0;
352     m_passwordEnd = 0;
353     m_hostEnd = 0;
354     m_portEnd = 0;
355     m_pathEnd = 0;
356     m_pathAfterLastSlash = 0;
357     m_queryEnd = 0;
358     m_fragmentEnd = 0;
359 }
360
361 URL::URL(ParsedURLStringTag, const String& url)
362 {
363     URLParser parser(url);
364     *this = parser.result();
365
366 #if OS(WINDOWS)
367     // FIXME(148598): Work around Windows local file handling bug in CFNetwork
368     ASSERT(isLocalFile() || url == m_string);
369 #else
370     ASSERT(url == m_string);
371 #endif
372 }
373
374 URL::URL(const URL& base, const String& relative)
375 {
376     URLParser parser(relative, base);
377     *this = parser.result();
378 }
379
380 URL::URL(const URL& base, const String& relative, const TextEncoding& encoding)
381 {
382     // For UTF-{7,16,32}, we want to use UTF-8 for the query part as
383     // we do when submitting a form. A form with GET method
384     // has its contents added to a URL as query params and it makes sense
385     // to be consistent.
386     URLParser parser(relative, base, encoding.encodingForFormSubmission());
387     *this = parser.result();
388 }
389
390 static bool shouldTrimFromURL(UChar c)
391 {
392     // Browsers ignore leading/trailing whitespace and control
393     // characters from URLs.  Note that c is an *unsigned* char here
394     // so this comparison should only catch control characters.
395     return c <= ' ';
396 }
397
398 URL URL::isolatedCopy() const
399 {
400     URL result = *this;
401     result.m_string = result.m_string.isolatedCopy();
402     return result;
403 }
404
405 String URL::lastPathComponent() const
406 {
407     if (!hasPath())
408         return String();
409
410     unsigned end = m_pathEnd - 1;
411     if (m_string[end] == '/')
412         --end;
413
414     size_t start = m_string.reverseFind('/', end);
415     if (start < static_cast<unsigned>(m_portEnd))
416         return String();
417     ++start;
418
419     return m_string.substring(start, end - start + 1);
420 }
421
422 StringView URL::protocol() const
423 {
424     return StringView(m_string).substring(0, m_schemeEnd);
425 }
426
427 String URL::host() const
428 {
429     unsigned start = hostStart();
430     return m_string.substring(start, m_hostEnd - start);
431 }
432
433 std::optional<uint16_t> URL::port() const
434 {
435     if (!m_portEnd || m_hostEnd >= m_portEnd - 1)
436         return std::nullopt;
437
438     bool ok = false;
439     unsigned number;
440     if (m_string.is8Bit())
441         number = charactersToUIntStrict(m_string.characters8() + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
442     else
443         number = charactersToUIntStrict(m_string.characters16() + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
444     if (!ok || number > std::numeric_limits<uint16_t>::max())
445         return std::nullopt;
446     return number;
447 }
448
449 String URL::hostAndPort() const
450 {
451     if (auto port = this->port())
452         return host() + ':' + String::number(port.value());
453     return host();
454 }
455
456 String URL::protocolHostAndPort() const
457 {
458     String result = m_string.substring(0, m_portEnd);
459
460     if (m_passwordEnd - m_userStart > 0) {
461         const int allowForTrailingAtSign = 1;
462         result.remove(m_userStart, m_passwordEnd - m_userStart + allowForTrailingAtSign);
463     }
464
465     return result;
466 }
467
468 String URL::user() const
469 {
470     return decodeURLEscapeSequences(m_string.substring(m_userStart, m_userEnd - m_userStart));
471 }
472
473 String URL::pass() const
474 {
475     if (m_passwordEnd == m_userEnd)
476         return String();
477
478     return decodeURLEscapeSequences(m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1));
479 }
480
481 String URL::encodedUser() const
482 {
483     return m_string.substring(m_userStart, m_userEnd - m_userStart);
484 }
485
486 String URL::encodedPass() const
487 {
488     if (m_passwordEnd == m_userEnd)
489         return String();
490
491     return m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1);
492 }
493
494 String URL::fragmentIdentifier() const
495 {
496     if (m_fragmentEnd == m_queryEnd)
497         return String();
498
499     return m_string.substring(m_queryEnd + 1, m_fragmentEnd - (m_queryEnd + 1));
500 }
501
502 bool URL::hasFragmentIdentifier() const
503 {
504     return m_fragmentEnd != m_queryEnd;
505 }
506
507 String URL::baseAsString() const
508 {
509     return m_string.left(m_pathAfterLastSlash);
510 }
511
512 #if !USE(CF)
513
514 String URL::fileSystemPath() const
515 {
516     if (!isValid() || !isLocalFile())
517         return String();
518
519     return decodeURLEscapeSequences(path());
520 }
521
522 #endif
523
524 #ifdef NDEBUG
525
526 static inline void assertProtocolIsGood(StringView)
527 {
528 }
529
530 #else
531
532 static void assertProtocolIsGood(StringView protocol)
533 {
534     // FIXME: We probably don't need this function any more.
535     // The isASCIIAlphaCaselessEqual function asserts that passed-in characters
536     // are ones it can handle; the older code did not and relied on these checks.
537     for (auto character : protocol.codeUnits()) {
538         ASSERT(isASCII(character));
539         ASSERT(character > ' ');
540         ASSERT(!isASCIIUpper(character));
541         ASSERT(toASCIILowerUnchecked(character) == character);
542     }
543 }
544
545 #endif
546
547 static Lock& defaultPortForProtocolMapForTestingLock()
548 {
549     static NeverDestroyed<Lock> lock;
550     return lock;
551 }
552
553 using DefaultPortForProtocolMapForTesting = HashMap<String, uint16_t>;
554 static DefaultPortForProtocolMapForTesting*& defaultPortForProtocolMapForTesting()
555 {
556     static DefaultPortForProtocolMapForTesting* defaultPortForProtocolMap;
557     return defaultPortForProtocolMap;
558 }
559
560 static DefaultPortForProtocolMapForTesting& ensureDefaultPortForProtocolMapForTesting()
561 {
562     DefaultPortForProtocolMapForTesting*& defaultPortForProtocolMap = defaultPortForProtocolMapForTesting();
563     if (!defaultPortForProtocolMap)
564         defaultPortForProtocolMap = new DefaultPortForProtocolMapForTesting;
565     return *defaultPortForProtocolMap;
566 }
567
568 void registerDefaultPortForProtocolForTesting(uint16_t port, const String& protocol)
569 {
570     LockHolder locker(defaultPortForProtocolMapForTestingLock());
571     ensureDefaultPortForProtocolMapForTesting().add(protocol, port);
572 }
573
574 void clearDefaultPortForProtocolMapForTesting()
575 {
576     LockHolder locker(defaultPortForProtocolMapForTestingLock());
577     if (auto* map = defaultPortForProtocolMapForTesting())
578         map->clear();
579 }
580
581 std::optional<uint16_t> defaultPortForProtocol(StringView protocol)
582 {
583     if (auto* overrideMap = defaultPortForProtocolMapForTesting()) {
584         LockHolder locker(defaultPortForProtocolMapForTestingLock());
585         ASSERT(overrideMap); // No need to null check again here since overrideMap cannot become null after being non-null.
586         auto iterator = overrideMap->find(protocol.toStringWithoutCopying());
587         if (iterator != overrideMap->end())
588             return iterator->value;
589     }
590     return URLParser::defaultPortForProtocol(protocol);
591 }
592
593 bool isDefaultPortForProtocol(uint16_t port, StringView protocol)
594 {
595     return defaultPortForProtocol(protocol) == port;
596 }
597
598 bool URL::protocolIs(const char* protocol) const
599 {
600     assertProtocolIsGood(StringView(reinterpret_cast<const LChar*>(protocol), strlen(protocol)));
601
602     // JavaScript URLs are "valid" and should be executed even if URL decides they are invalid.
603     // The free function protocolIsJavaScript() should be used instead. 
604     ASSERT(!equalLettersIgnoringASCIICase(StringView(protocol), "javascript"));
605
606     if (!m_isValid)
607         return false;
608
609     // Do the comparison without making a new string object.
610     for (unsigned i = 0; i < m_schemeEnd; ++i) {
611         if (!protocol[i] || !isASCIIAlphaCaselessEqual(m_string[i], protocol[i]))
612             return false;
613     }
614     return !protocol[m_schemeEnd]; // We should have consumed all characters in the argument.
615 }
616
617 bool URL::protocolIs(StringView protocol) const
618 {
619     assertProtocolIsGood(protocol);
620
621     if (!m_isValid)
622         return false;
623     
624     if (m_schemeEnd != protocol.length())
625         return false;
626
627     // Do the comparison without making a new string object.
628     for (unsigned i = 0; i < m_schemeEnd; ++i) {
629         if (!isASCIIAlphaCaselessEqual(m_string[i], protocol[i]))
630             return false;
631     }
632     return true;
633 }
634
635 String URL::query() const
636 {
637     if (m_queryEnd == m_pathEnd)
638         return String();
639
640     return m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); 
641 }
642
643 String URL::path() const
644 {
645     return m_string.substring(m_portEnd, m_pathEnd - m_portEnd);
646 }
647
648 bool URL::setProtocol(const String& s)
649 {
650     // Firefox and IE remove everything after the first ':'.
651     size_t separatorPosition = s.find(':');
652     String newProtocol = s.substring(0, separatorPosition);
653
654     if (!isValidProtocol(newProtocol))
655         return false;
656
657     if (!m_isValid) {
658         URLParser parser(makeString(newProtocol, ":", m_string));
659         *this = parser.result();
660         return true;
661     }
662
663     URLParser parser(makeString(newProtocol, m_string.substring(m_schemeEnd)));
664     *this = parser.result();
665     return true;
666 }
667
668 static bool containsOnlyASCII(StringView string)
669 {
670     if (string.is8Bit())
671         return charactersAreAllASCII(string.characters8(), string.length());
672     return charactersAreAllASCII(string.characters16(), string.length());
673 }
674     
675 // Appends the punycoded hostname identified by the given string and length to
676 // the output buffer. The result will not be null terminated.
677 // Return value of false means error in encoding.
678 static bool appendEncodedHostname(UCharBuffer& buffer, StringView string)
679 {
680     // Needs to be big enough to hold an IDN-encoded name.
681     // For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
682     const unsigned hostnameBufferLength = 2048;
683     
684     if (string.length() > hostnameBufferLength || containsOnlyASCII(string)) {
685         append(buffer, string);
686         return true;
687     }
688     
689     UChar hostnameBuffer[hostnameBufferLength];
690     UErrorCode error = U_ZERO_ERROR;
691     
692 #if COMPILER(GCC_OR_CLANG)
693 #pragma GCC diagnostic push
694 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
695 #endif
696     int32_t numCharactersConverted = uidna_IDNToASCII(string.upconvertedCharacters(), string.length(), hostnameBuffer,
697         hostnameBufferLength, UIDNA_ALLOW_UNASSIGNED, 0, &error);
698 #if COMPILER(GCC_OR_CLANG)
699 #pragma GCC diagnostic pop
700 #endif
701     
702     if (error == U_ZERO_ERROR) {
703         buffer.append(hostnameBuffer, numCharactersConverted);
704         return true;
705     }
706     return false;
707 }
708     
709 void URL::setHost(const String& s)
710 {
711     if (!m_isValid)
712         return;
713
714     auto colonIndex = s.find(':');
715     if (colonIndex != notFound)
716         return;
717
718     UCharBuffer encodedHostName;
719     if (!appendEncodedHostname(encodedHostName, s))
720         return;
721     
722     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
723     
724     StringBuilder builder;
725     builder.append(m_string.left(hostStart()));
726     if (slashSlashNeeded)
727         builder.appendLiteral("//");
728     builder.append(StringView(encodedHostName.data(), encodedHostName.size()));
729     builder.append(m_string.substring(m_hostEnd));
730
731     URLParser parser(builder.toString());
732     *this = parser.result();
733 }
734
735 void URL::removePort()
736 {
737     if (m_hostEnd == m_portEnd)
738         return;
739     URLParser parser(m_string.left(m_hostEnd) + m_string.substring(m_portEnd));
740     *this = parser.result();
741 }
742
743 void URL::setPort(unsigned short i)
744 {
745     if (!m_isValid)
746         return;
747
748     bool colonNeeded = m_portEnd == m_hostEnd;
749     unsigned portStart = (colonNeeded ? m_hostEnd : m_hostEnd + 1);
750
751     URLParser parser(makeString(m_string.left(portStart), (colonNeeded ? ":" : ""), String::number(i), m_string.substring(m_portEnd)));
752     *this = parser.result();
753 }
754
755 void URL::setHostAndPort(const String& hostAndPort)
756 {
757     if (!m_isValid)
758         return;
759
760     StringView hostName(hostAndPort);
761     StringView port;
762     
763     auto colonIndex = hostName.find(':');
764     if (colonIndex != notFound) {
765         port = hostName.substring(colonIndex + 1);
766         bool ok;
767         int portInt = port.toIntStrict(ok);
768         if (!ok || portInt < 0)
769             return;
770         hostName = hostName.substring(0, colonIndex);
771     }
772
773     if (hostName.isEmpty())
774         return;
775
776     UCharBuffer encodedHostName;
777     if (!appendEncodedHostname(encodedHostName, hostName))
778         return;
779
780     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
781
782     StringBuilder builder;
783     builder.append(m_string.left(hostStart()));
784     if (slashSlashNeeded)
785         builder.appendLiteral("//");
786     builder.append(StringView(encodedHostName.data(), encodedHostName.size()));
787     if (!port.isEmpty()) {
788         builder.appendLiteral(":");
789         builder.append(port);
790     }
791     builder.append(m_string.substring(m_portEnd));
792
793     URLParser parser(builder.toString());
794     *this = parser.result();
795 }
796
797 void URL::setUser(const String& user)
798 {
799     if (!m_isValid)
800         return;
801
802     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
803     // and to avoid changing more than just the user login.
804
805     unsigned end = m_userEnd;
806     if (!user.isEmpty()) {
807         String u = encodeWithURLEscapeSequences(user, PercentEncodeUsername);
808         if (m_userStart == m_schemeEnd + 1)
809             u = "//" + u;
810         // Add '@' if we didn't have one before.
811         if (end == m_hostEnd || (end == m_passwordEnd && m_string[end] != '@'))
812             u.append('@');
813         URLParser parser(makeString(m_string.left(m_userStart), u, m_string.substring(end)));
814         *this = parser.result();
815     } else {
816         // Remove '@' if we now have neither user nor password.
817         if (m_userEnd == m_passwordEnd && end != m_hostEnd && m_string[end] == '@')
818             end += 1;
819         // We don't want to parse in the extremely common case where we are not going to make a change.
820         if (m_userStart != end) {
821             URLParser parser(makeString(m_string.left(m_userStart), m_string.substring(end)));
822             *this = parser.result();
823         }
824     }
825 }
826
827 void URL::setPass(const String& password)
828 {
829     if (!m_isValid)
830         return;
831
832     unsigned end = m_passwordEnd;
833     if (!password.isEmpty()) {
834         String p = ":" + encodeWithURLEscapeSequences(password, PercentEncodePassword) + "@";
835         if (m_userEnd == m_schemeEnd + 1)
836             p = "//" + p;
837         // Eat the existing '@' since we are going to add our own.
838         if (end != m_hostEnd && m_string[end] == '@')
839             end += 1;
840         URLParser parser(makeString(m_string.left(m_userEnd), p, m_string.substring(end)));
841         *this = parser.result();
842     } else {
843         // Remove '@' if we now have neither user nor password.
844         if (m_userStart == m_userEnd && end != m_hostEnd && m_string[end] == '@')
845             end += 1;
846         // We don't want to parse in the extremely common case where we are not going to make a change.
847         if (m_userEnd != end) {
848             URLParser parser(makeString(m_string.left(m_userEnd), m_string.substring(end)));
849             *this = parser.result();
850         }
851     }
852 }
853
854 void URL::setFragmentIdentifier(StringView identifier)
855 {
856     if (!m_isValid)
857         return;
858
859     // FIXME: Optimize the case where the identifier already happens to be equal to what was passed?
860     // FIXME: Is it correct to do this without encoding and escaping non-ASCII characters?
861     *this = URLParser { makeString(StringView { m_string }.substring(0, m_queryEnd), '#', identifier) }.result();
862 }
863
864 void URL::removeFragmentIdentifier()
865 {
866     if (!m_isValid) {
867         ASSERT(!m_fragmentEnd);
868         ASSERT(!m_queryEnd);
869         return;
870     }
871     if (m_fragmentEnd > m_queryEnd)
872         m_string = m_string.left(m_queryEnd);
873     m_fragmentEnd = m_queryEnd;
874 }
875     
876 void URL::setQuery(const String& query)
877 {
878     if (!m_isValid)
879         return;
880
881     // FIXME: '#' and non-ASCII characters must be encoded and escaped.
882     // Usually, the query is encoded using document encoding, not UTF-8, but we don't have
883     // access to the document in this function.
884     // https://webkit.org/b/161176
885     if ((query.isEmpty() || query[0] != '?') && !query.isNull()) {
886         URLParser parser(makeString(m_string.left(m_pathEnd), "?", query, m_string.substring(m_queryEnd)));
887         *this = parser.result();
888     } else {
889         URLParser parser(makeString(m_string.left(m_pathEnd), query, m_string.substring(m_queryEnd)));
890         *this = parser.result();
891     }
892
893 }
894
895 void URL::setPath(const String& s)
896 {
897     if (!m_isValid)
898         return;
899
900     // FIXME: encodeWithURLEscapeSequences does not correctly escape '#' and '?', so fragment and query parts
901     // may be inadvertently affected.
902     String path = s;
903     if (path.isEmpty() || path[0] != '/')
904         path = "/" + path;
905
906     URLParser parser(makeString(m_string.left(m_portEnd), encodeWithURLEscapeSequences(path), m_string.substring(m_pathEnd)));
907     *this = parser.result();
908 }
909
910 String decodeURLEscapeSequences(const String& string)
911 {
912     return decodeEscapeSequences<URLEscapeSequence>(string, UTF8Encoding());
913 }
914
915 String decodeURLEscapeSequences(const String& string, const TextEncoding& encoding)
916 {
917     return decodeEscapeSequences<URLEscapeSequence>(string, encoding);
918 }
919
920 // Caution: This function does not bounds check.
921 static void appendEscapedChar(char*& buffer, unsigned char c)
922 {
923     *buffer++ = '%';
924     placeByteAsHex(c, buffer);
925 }
926
927 String URL::serialize(bool omitFragment) const
928 {
929     if (omitFragment)
930         return m_string.left(m_queryEnd);
931     return m_string;
932 }
933
934 #if PLATFORM(IOS)
935
936 static bool shouldCanonicalizeScheme = true;
937
938 void enableURLSchemeCanonicalization(bool enableSchemeCanonicalization)
939 {
940     shouldCanonicalizeScheme = enableSchemeCanonicalization;
941 }
942
943 #endif
944
945 template<size_t length>
946 static inline bool equal(const char* a, const char (&b)[length])
947 {
948 #if PLATFORM(IOS)
949     if (!shouldCanonicalizeScheme) {
950         for (size_t i = 0; i < length; ++i) {
951             if (toASCIILower(a[i]) != b[i])
952                 return false;
953         }
954         return true;
955     }
956 #endif
957     for (size_t i = 0; i < length; ++i) {
958         if (a[i] != b[i])
959             return false;
960     }
961     return true;
962 }
963
964 template<size_t lengthB>
965 static inline bool equal(const char* stringA, size_t lengthA, const char (&stringB)[lengthB])
966 {
967     return lengthA == lengthB && equal(stringA, stringB);
968 }
969
970 bool equalIgnoringFragmentIdentifier(const URL& a, const URL& b)
971 {
972     if (a.m_queryEnd != b.m_queryEnd)
973         return false;
974     unsigned queryLength = a.m_queryEnd;
975     for (unsigned i = 0; i < queryLength; ++i)
976         if (a.string()[i] != b.string()[i])
977             return false;
978     return true;
979 }
980
981 bool protocolHostAndPortAreEqual(const URL& a, const URL& b)
982 {
983     if (a.m_schemeEnd != b.m_schemeEnd)
984         return false;
985
986     unsigned hostStartA = a.hostStart();
987     unsigned hostLengthA = a.hostEnd() - hostStartA;
988     unsigned hostStartB = b.hostStart();
989     unsigned hostLengthB = b.hostEnd() - b.hostStart();
990     if (hostLengthA != hostLengthB)
991         return false;
992
993     // Check the scheme
994     for (unsigned i = 0; i < a.m_schemeEnd; ++i) {
995         if (a.string()[i] != b.string()[i])
996             return false;
997     }
998
999     // And the host
1000     for (unsigned i = 0; i < hostLengthA; ++i) {
1001         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
1002             return false;
1003     }
1004
1005     if (a.port() != b.port())
1006         return false;
1007
1008     return true;
1009 }
1010
1011 bool hostsAreEqual(const URL& a, const URL& b)
1012 {
1013     unsigned hostStartA = a.hostStart();
1014     unsigned hostLengthA = a.hostEnd() - hostStartA;
1015     unsigned hostStartB = b.hostStart();
1016     unsigned hostLengthB = b.hostEnd() - hostStartB;
1017     if (hostLengthA != hostLengthB)
1018         return false;
1019
1020     for (unsigned i = 0; i < hostLengthA; ++i) {
1021         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
1022             return false;
1023     }
1024
1025     return true;
1026 }
1027
1028 String encodeWithURLEscapeSequences(const String& notEncodedString, PercentEncodeCharacterClass whatToEncode)
1029 {
1030     CString asUTF8 = notEncodedString.utf8();
1031
1032     CharBuffer buffer(asUTF8.length() * 3 + 1);
1033     char* p = buffer.data();
1034
1035     const char* str = asUTF8.data();
1036     const char* strEnd = str + asUTF8.length();
1037     while (str < strEnd) {
1038         unsigned char c = *str++;
1039         if (percentEncodeClassTable[c] >= whatToEncode)
1040             appendEscapedChar(p, c);
1041         else
1042             *p++ = c;
1043     }
1044
1045     ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
1046
1047     return String(buffer.data(), p - buffer.data());
1048 }
1049
1050 String encodeWithURLEscapeSequences(const String& notEncodedString)
1051 {
1052     CString asUTF8 = notEncodedString.utf8();
1053
1054     CharBuffer buffer(asUTF8.length() * 3 + 1);
1055     char* p = buffer.data();
1056
1057     const char* str = asUTF8.data();
1058     const char* strEnd = str + asUTF8.length();
1059     while (str < strEnd) {
1060         unsigned char c = *str++;
1061         if (isBadChar(c))
1062             appendEscapedChar(p, c);
1063         else
1064             *p++ = c;
1065     }
1066
1067     ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
1068
1069     return String(buffer.data(), p - buffer.data());
1070 }
1071
1072 bool URL::isHierarchical() const
1073 {
1074     if (!m_isValid)
1075         return false;
1076     ASSERT(m_string[m_schemeEnd] == ':');
1077     return m_string[m_schemeEnd + 1] == '/';
1078 }
1079
1080 void URL::copyToBuffer(Vector<char, 512>& buffer) const
1081 {
1082     // FIXME: This throws away the high bytes of all the characters in the string!
1083     // That's fine for a valid URL, which is all ASCII, but not for invalid URLs.
1084     buffer.resize(m_string.length());
1085     copyASCII(m_string, buffer.data());
1086 }
1087
1088 template<typename StringClass>
1089 bool protocolIsInternal(const StringClass& url, const char* protocol)
1090 {
1091     // Do the comparison without making a new string object.
1092     assertProtocolIsGood(StringView(reinterpret_cast<const LChar*>(protocol), strlen(protocol)));
1093     bool isLeading = true;
1094     for (unsigned i = 0, j = 0; url[i]; ++i) {
1095         // Skip leading whitespace and control characters.
1096         if (isLeading && shouldTrimFromURL(url[i]))
1097             continue;
1098         isLeading = false;
1099
1100         // Skip any tabs and newlines.
1101         if (isTabNewline(url[i]))
1102             continue;
1103
1104         if (!protocol[j])
1105             return url[i] == ':';
1106         if (!isASCIIAlphaCaselessEqual(url[i], protocol[j]))
1107             return false;
1108
1109         ++j;
1110     }
1111     
1112     return false;
1113 }
1114
1115 bool protocolIs(const String& url, const char* protocol)
1116 {
1117     return protocolIsInternal(url, protocol);
1118 }
1119
1120 inline bool URL::protocolIs(const String& string, const char* protocol)
1121 {
1122     return WebCore::protocolIsInternal(string, protocol);
1123 }
1124
1125 bool isValidProtocol(const String& protocol)
1126 {
1127     // RFC3986: ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
1128     if (protocol.isEmpty())
1129         return false;
1130     if (!isSchemeFirstChar(protocol[0]))
1131         return false;
1132     unsigned protocolLength = protocol.length();
1133     for (unsigned i = 1; i < protocolLength; i++) {
1134         if (!isSchemeChar(protocol[i]))
1135             return false;
1136     }
1137     return true;
1138 }
1139
1140 #ifndef NDEBUG
1141
1142 void URL::print() const
1143 {
1144     printf("%s\n", m_string.utf8().data());
1145 }
1146
1147 #endif
1148
1149 String URL::strippedForUseAsReferrer() const
1150 {
1151     URL referrer(*this);
1152     referrer.setUser(String());
1153     referrer.setPass(String());
1154     referrer.removeFragmentIdentifier();
1155     return referrer.string();
1156 }
1157
1158 bool URL::isLocalFile() const
1159 {
1160     // Including feed here might be a bad idea since drag and drop uses this check
1161     // and including feed would allow feeds to potentially let someone's blog
1162     // read the contents of the clipboard on a drag, even without a drop.
1163     // Likewise with using the FrameLoader::shouldTreatURLAsLocal() function.
1164     return protocolIs("file");
1165 }
1166
1167 bool protocolIsJavaScript(const String& url)
1168 {
1169     return protocolIsInternal(url, "javascript");
1170 }
1171
1172 bool protocolIsJavaScript(StringView url)
1173 {
1174     return protocolIsInternal(url, "javascript");
1175 }
1176
1177 bool protocolIsInHTTPFamily(const String& url)
1178 {
1179     // Do the comparison without making a new string object.
1180     return isASCIIAlphaCaselessEqual(url[0], 'h')
1181         && isASCIIAlphaCaselessEqual(url[1], 't')
1182         && isASCIIAlphaCaselessEqual(url[2], 't')
1183         && isASCIIAlphaCaselessEqual(url[3], 'p')
1184         && (url[4] == ':' || (isASCIIAlphaCaselessEqual(url[4], 's') && url[5] == ':'));
1185 }
1186
1187 const URL& blankURL()
1188 {
1189     static NeverDestroyed<URL> staticBlankURL(ParsedURLString, "about:blank");
1190     return staticBlankURL;
1191 }
1192
1193 bool URL::isBlankURL() const
1194 {
1195     return protocolIs("about");
1196 }
1197
1198 bool portAllowed(const URL& url)
1199 {
1200     std::optional<uint16_t> port = url.port();
1201
1202     // Since most URLs don't have a port, return early for the "no port" case.
1203     if (!port)
1204         return true;
1205
1206     // This blocked port list matches the port blocking that Mozilla implements.
1207     // See http://www.mozilla.org/projects/netlib/PortBanning.html for more information.
1208     static const uint16_t blockedPortList[] = {
1209         1,    // tcpmux
1210         7,    // echo
1211         9,    // discard
1212         11,   // systat
1213         13,   // daytime
1214         15,   // netstat
1215         17,   // qotd
1216         19,   // chargen
1217         20,   // FTP-data
1218         21,   // FTP-control
1219         22,   // SSH
1220         23,   // telnet
1221         25,   // SMTP
1222         37,   // time
1223         42,   // name
1224         43,   // nicname
1225         53,   // domain
1226         77,   // priv-rjs
1227         79,   // finger
1228         87,   // ttylink
1229         95,   // supdup
1230         101,  // hostriame
1231         102,  // iso-tsap
1232         103,  // gppitnp
1233         104,  // acr-nema
1234         109,  // POP2
1235         110,  // POP3
1236         111,  // sunrpc
1237         113,  // auth
1238         115,  // SFTP
1239         117,  // uucp-path
1240         119,  // nntp
1241         123,  // NTP
1242         135,  // loc-srv / epmap
1243         139,  // netbios
1244         143,  // IMAP2
1245         179,  // BGP
1246         389,  // LDAP
1247         465,  // SMTP+SSL
1248         512,  // print / exec
1249         513,  // login
1250         514,  // shell
1251         515,  // printer
1252         526,  // tempo
1253         530,  // courier
1254         531,  // Chat
1255         532,  // netnews
1256         540,  // UUCP
1257         556,  // remotefs
1258         563,  // NNTP+SSL
1259         587,  // ESMTP
1260         601,  // syslog-conn
1261         636,  // LDAP+SSL
1262         993,  // IMAP+SSL
1263         995,  // POP3+SSL
1264         2049, // NFS
1265         3659, // apple-sasl / PasswordServer [Apple addition]
1266         4045, // lockd
1267         4190, // ManageSieve [Apple addition]
1268         6000, // X11
1269         6665, // Alternate IRC [Apple addition]
1270         6666, // Alternate IRC [Apple addition]
1271         6667, // Standard IRC [Apple addition]
1272         6668, // Alternate IRC [Apple addition]
1273         6669, // Alternate IRC [Apple addition]
1274         invalidPortNumber, // Used to block all invalid port numbers
1275     };
1276
1277     // If the port is not in the blocked port list, allow it.
1278     ASSERT(std::is_sorted(std::begin(blockedPortList), std::end(blockedPortList)));
1279     if (!std::binary_search(std::begin(blockedPortList), std::end(blockedPortList), port.value()))
1280         return true;
1281
1282     // Allow ports 21 and 22 for FTP URLs, as Mozilla does.
1283     if ((port.value() == 21 || port.value() == 22) && url.protocolIs("ftp"))
1284         return true;
1285
1286     // Allow any port number in a file URL, since the port number is ignored.
1287     if (url.protocolIs("file"))
1288         return true;
1289
1290     return false;
1291 }
1292
1293 String mimeTypeFromDataURL(const String& url)
1294 {
1295     ASSERT(protocolIsInternal(url, "data"));
1296
1297     // FIXME: What's the right behavior when the URL has a comma first, but a semicolon later?
1298     // Currently this code will break at the semicolon in that case. Not sure that's correct.
1299     auto index = url.find(';', 5);
1300     if (index == notFound)
1301         index = url.find(',', 5);
1302     if (index == notFound) {
1303         // FIXME: There was an old comment here that made it sound like this should be returning text/plain.
1304         // But we have been returning empty string here for some time, so not changing its behavior at this time.
1305         return emptyString();
1306     }
1307     if (index == 5)
1308         return ASCIILiteral("text/plain");
1309     ASSERT(index >= 5);
1310     return url.substring(5, index - 5).convertToASCIILowercase();
1311 }
1312
1313 String mimeTypeFromURL(const URL& url)
1314 {
1315     String decodedPath = decodeURLEscapeSequences(url.path());
1316     String extension = decodedPath.substring(decodedPath.reverseFind('.') + 1);
1317
1318     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
1319     return MIMETypeRegistry::getMIMETypeForExtension(extension);
1320 }
1321
1322 String URL::stringCenterEllipsizedToLength(unsigned length) const
1323 {
1324     if (string().length() <= length)
1325         return string();
1326
1327     return string().left(length / 2 - 1) + "..." + string().right(length / 2 - 2);
1328 }
1329
1330 URL URL::fakeURLWithRelativePart(const String& relativePart)
1331 {
1332     return URL(URL(), "webkit-fake-url://" + createCanonicalUUIDString() + '/' + relativePart);
1333 }
1334
1335 URL URL::fileURLWithFileSystemPath(const String& filePath)
1336 {
1337     return URL(URL(), "file:///" + filePath);
1338 }
1339
1340 }