Reduce URL size
[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 }
359
360 URL::URL(ParsedURLStringTag, const String& url)
361 {
362     URLParser parser(url);
363     *this = parser.result();
364
365 #if OS(WINDOWS)
366     // FIXME(148598): Work around Windows local file handling bug in CFNetwork
367     ASSERT(isLocalFile() || url == m_string);
368 #else
369     ASSERT(url == m_string);
370 #endif
371 }
372
373 URL::URL(const URL& base, const String& relative)
374 {
375     URLParser parser(relative, base);
376     *this = parser.result();
377 }
378
379 URL::URL(const URL& base, const String& relative, const TextEncoding& encoding)
380 {
381     // For UTF-{7,16,32}, we want to use UTF-8 for the query part as
382     // we do when submitting a form. A form with GET method
383     // has its contents added to a URL as query params and it makes sense
384     // to be consistent.
385     URLParser parser(relative, base, encoding.encodingForFormSubmission());
386     *this = parser.result();
387 }
388
389 static bool shouldTrimFromURL(UChar c)
390 {
391     // Browsers ignore leading/trailing whitespace and control
392     // characters from URLs.  Note that c is an *unsigned* char here
393     // so this comparison should only catch control characters.
394     return c <= ' ';
395 }
396
397 URL URL::isolatedCopy() const
398 {
399     URL result = *this;
400     result.m_string = result.m_string.isolatedCopy();
401     return result;
402 }
403
404 String URL::lastPathComponent() const
405 {
406     if (!hasPath())
407         return String();
408
409     unsigned end = m_pathEnd - 1;
410     if (m_string[end] == '/')
411         --end;
412
413     size_t start = m_string.reverseFind('/', end);
414     if (start < static_cast<unsigned>(m_portEnd))
415         return String();
416     ++start;
417
418     return m_string.substring(start, end - start + 1);
419 }
420
421 StringView URL::protocol() const
422 {
423     return StringView(m_string).substring(0, m_schemeEnd);
424 }
425
426 String URL::host() const
427 {
428     unsigned start = hostStart();
429     return m_string.substring(start, m_hostEnd - start);
430 }
431
432 std::optional<uint16_t> URL::port() const
433 {
434     if (!m_portEnd || m_hostEnd >= m_portEnd - 1)
435         return std::nullopt;
436
437     bool ok = false;
438     unsigned number;
439     if (m_string.is8Bit())
440         number = charactersToUIntStrict(m_string.characters8() + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
441     else
442         number = charactersToUIntStrict(m_string.characters16() + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
443     if (!ok || number > std::numeric_limits<uint16_t>::max())
444         return std::nullopt;
445     return number;
446 }
447
448 String URL::hostAndPort() const
449 {
450     if (auto port = this->port())
451         return host() + ':' + String::number(port.value());
452     return host();
453 }
454
455 String URL::protocolHostAndPort() const
456 {
457     String result = m_string.substring(0, m_portEnd);
458
459     if (m_passwordEnd - m_userStart > 0) {
460         const int allowForTrailingAtSign = 1;
461         result.remove(m_userStart, m_passwordEnd - m_userStart + allowForTrailingAtSign);
462     }
463
464     return result;
465 }
466
467 String URL::user() const
468 {
469     return decodeURLEscapeSequences(m_string.substring(m_userStart, m_userEnd - m_userStart));
470 }
471
472 String URL::pass() const
473 {
474     if (m_passwordEnd == m_userEnd)
475         return String();
476
477     return decodeURLEscapeSequences(m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1));
478 }
479
480 String URL::encodedUser() const
481 {
482     return m_string.substring(m_userStart, m_userEnd - m_userStart);
483 }
484
485 String URL::encodedPass() const
486 {
487     if (m_passwordEnd == m_userEnd)
488         return String();
489
490     return m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1);
491 }
492
493 String URL::fragmentIdentifier() const
494 {
495     if (!m_isValid || m_queryEnd == m_string.length())
496         return String();
497
498     return m_string.substring(m_queryEnd + 1);
499 }
500
501 bool URL::hasFragmentIdentifier() const
502 {
503     return m_isValid && m_string.length() != m_queryEnd;
504 }
505
506 String URL::baseAsString() const
507 {
508     return m_string.left(m_pathAfterLastSlash);
509 }
510
511 #if !USE(CF)
512
513 String URL::fileSystemPath() const
514 {
515     if (!isValid() || !isLocalFile())
516         return String();
517
518     return decodeURLEscapeSequences(path());
519 }
520
521 #endif
522
523 #ifdef NDEBUG
524
525 static inline void assertProtocolIsGood(StringView)
526 {
527 }
528
529 #else
530
531 static void assertProtocolIsGood(StringView protocol)
532 {
533     // FIXME: We probably don't need this function any more.
534     // The isASCIIAlphaCaselessEqual function asserts that passed-in characters
535     // are ones it can handle; the older code did not and relied on these checks.
536     for (auto character : protocol.codeUnits()) {
537         ASSERT(isASCII(character));
538         ASSERT(character > ' ');
539         ASSERT(!isASCIIUpper(character));
540         ASSERT(toASCIILowerUnchecked(character) == character);
541     }
542 }
543
544 #endif
545
546 static Lock& defaultPortForProtocolMapForTestingLock()
547 {
548     static NeverDestroyed<Lock> lock;
549     return lock;
550 }
551
552 using DefaultPortForProtocolMapForTesting = HashMap<String, uint16_t>;
553 static DefaultPortForProtocolMapForTesting*& defaultPortForProtocolMapForTesting()
554 {
555     static DefaultPortForProtocolMapForTesting* defaultPortForProtocolMap;
556     return defaultPortForProtocolMap;
557 }
558
559 static DefaultPortForProtocolMapForTesting& ensureDefaultPortForProtocolMapForTesting()
560 {
561     DefaultPortForProtocolMapForTesting*& defaultPortForProtocolMap = defaultPortForProtocolMapForTesting();
562     if (!defaultPortForProtocolMap)
563         defaultPortForProtocolMap = new DefaultPortForProtocolMapForTesting;
564     return *defaultPortForProtocolMap;
565 }
566
567 void registerDefaultPortForProtocolForTesting(uint16_t port, const String& protocol)
568 {
569     LockHolder locker(defaultPortForProtocolMapForTestingLock());
570     ensureDefaultPortForProtocolMapForTesting().add(protocol, port);
571 }
572
573 void clearDefaultPortForProtocolMapForTesting()
574 {
575     LockHolder locker(defaultPortForProtocolMapForTestingLock());
576     if (auto* map = defaultPortForProtocolMapForTesting())
577         map->clear();
578 }
579
580 std::optional<uint16_t> defaultPortForProtocol(StringView protocol)
581 {
582     if (auto* overrideMap = defaultPortForProtocolMapForTesting()) {
583         LockHolder locker(defaultPortForProtocolMapForTestingLock());
584         ASSERT(overrideMap); // No need to null check again here since overrideMap cannot become null after being non-null.
585         auto iterator = overrideMap->find(protocol.toStringWithoutCopying());
586         if (iterator != overrideMap->end())
587             return iterator->value;
588     }
589     return URLParser::defaultPortForProtocol(protocol);
590 }
591
592 bool isDefaultPortForProtocol(uint16_t port, StringView protocol)
593 {
594     return defaultPortForProtocol(protocol) == port;
595 }
596
597 bool URL::protocolIs(const char* protocol) const
598 {
599     assertProtocolIsGood(StringView(reinterpret_cast<const LChar*>(protocol), strlen(protocol)));
600
601     // JavaScript URLs are "valid" and should be executed even if URL decides they are invalid.
602     // The free function protocolIsJavaScript() should be used instead. 
603     ASSERT(!equalLettersIgnoringASCIICase(StringView(protocol), "javascript"));
604
605     if (!m_isValid)
606         return false;
607
608     // Do the comparison without making a new string object.
609     for (unsigned i = 0; i < m_schemeEnd; ++i) {
610         if (!protocol[i] || !isASCIIAlphaCaselessEqual(m_string[i], protocol[i]))
611             return false;
612     }
613     return !protocol[m_schemeEnd]; // We should have consumed all characters in the argument.
614 }
615
616 bool URL::protocolIs(StringView protocol) const
617 {
618     assertProtocolIsGood(protocol);
619
620     if (!m_isValid)
621         return false;
622     
623     if (m_schemeEnd != protocol.length())
624         return false;
625
626     // Do the comparison without making a new string object.
627     for (unsigned i = 0; i < m_schemeEnd; ++i) {
628         if (!isASCIIAlphaCaselessEqual(m_string[i], protocol[i]))
629             return false;
630     }
631     return true;
632 }
633
634 String URL::query() const
635 {
636     if (m_queryEnd == m_pathEnd)
637         return String();
638
639     return m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); 
640 }
641
642 String URL::path() const
643 {
644     return m_string.substring(m_portEnd, m_pathEnd - m_portEnd);
645 }
646
647 bool URL::setProtocol(const String& s)
648 {
649     // Firefox and IE remove everything after the first ':'.
650     size_t separatorPosition = s.find(':');
651     String newProtocol = s.substring(0, separatorPosition);
652
653     if (!isValidProtocol(newProtocol))
654         return false;
655
656     if (!m_isValid) {
657         URLParser parser(makeString(newProtocol, ":", m_string));
658         *this = parser.result();
659         return true;
660     }
661
662     URLParser parser(makeString(newProtocol, m_string.substring(m_schemeEnd)));
663     *this = parser.result();
664     return true;
665 }
666
667 static bool containsOnlyASCII(StringView string)
668 {
669     if (string.is8Bit())
670         return charactersAreAllASCII(string.characters8(), string.length());
671     return charactersAreAllASCII(string.characters16(), string.length());
672 }
673     
674 // Appends the punycoded hostname identified by the given string and length to
675 // the output buffer. The result will not be null terminated.
676 // Return value of false means error in encoding.
677 static bool appendEncodedHostname(UCharBuffer& buffer, StringView string)
678 {
679     // Needs to be big enough to hold an IDN-encoded name.
680     // For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
681     const unsigned hostnameBufferLength = 2048;
682     
683     if (string.length() > hostnameBufferLength || containsOnlyASCII(string)) {
684         append(buffer, string);
685         return true;
686     }
687     
688     UChar hostnameBuffer[hostnameBufferLength];
689     UErrorCode error = U_ZERO_ERROR;
690     
691 #if COMPILER(GCC_OR_CLANG)
692 #pragma GCC diagnostic push
693 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
694 #endif
695     int32_t numCharactersConverted = uidna_IDNToASCII(string.upconvertedCharacters(), string.length(), hostnameBuffer,
696         hostnameBufferLength, UIDNA_ALLOW_UNASSIGNED, 0, &error);
697 #if COMPILER(GCC_OR_CLANG)
698 #pragma GCC diagnostic pop
699 #endif
700     
701     if (error == U_ZERO_ERROR) {
702         buffer.append(hostnameBuffer, numCharactersConverted);
703         return true;
704     }
705     return false;
706 }
707     
708 void URL::setHost(const String& s)
709 {
710     if (!m_isValid)
711         return;
712
713     auto colonIndex = s.find(':');
714     if (colonIndex != notFound)
715         return;
716
717     UCharBuffer encodedHostName;
718     if (!appendEncodedHostname(encodedHostName, s))
719         return;
720     
721     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
722     
723     StringBuilder builder;
724     builder.append(m_string.left(hostStart()));
725     if (slashSlashNeeded)
726         builder.appendLiteral("//");
727     builder.append(StringView(encodedHostName.data(), encodedHostName.size()));
728     builder.append(m_string.substring(m_hostEnd));
729
730     URLParser parser(builder.toString());
731     *this = parser.result();
732 }
733
734 void URL::removePort()
735 {
736     if (m_hostEnd == m_portEnd)
737         return;
738     URLParser parser(m_string.left(m_hostEnd) + m_string.substring(m_portEnd));
739     *this = parser.result();
740 }
741
742 void URL::setPort(unsigned short i)
743 {
744     if (!m_isValid)
745         return;
746
747     bool colonNeeded = m_portEnd == m_hostEnd;
748     unsigned portStart = (colonNeeded ? m_hostEnd : m_hostEnd + 1);
749
750     URLParser parser(makeString(m_string.left(portStart), (colonNeeded ? ":" : ""), String::number(i), m_string.substring(m_portEnd)));
751     *this = parser.result();
752 }
753
754 void URL::setHostAndPort(const String& hostAndPort)
755 {
756     if (!m_isValid)
757         return;
758
759     StringView hostName(hostAndPort);
760     StringView port;
761     
762     auto colonIndex = hostName.find(':');
763     if (colonIndex != notFound) {
764         port = hostName.substring(colonIndex + 1);
765         bool ok;
766         int portInt = port.toIntStrict(ok);
767         if (!ok || portInt < 0)
768             return;
769         hostName = hostName.substring(0, colonIndex);
770     }
771
772     if (hostName.isEmpty())
773         return;
774
775     UCharBuffer encodedHostName;
776     if (!appendEncodedHostname(encodedHostName, hostName))
777         return;
778
779     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
780
781     StringBuilder builder;
782     builder.append(m_string.left(hostStart()));
783     if (slashSlashNeeded)
784         builder.appendLiteral("//");
785     builder.append(StringView(encodedHostName.data(), encodedHostName.size()));
786     if (!port.isEmpty()) {
787         builder.appendLiteral(":");
788         builder.append(port);
789     }
790     builder.append(m_string.substring(m_portEnd));
791
792     URLParser parser(builder.toString());
793     *this = parser.result();
794 }
795
796 void URL::setUser(const String& user)
797 {
798     if (!m_isValid)
799         return;
800
801     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
802     // and to avoid changing more than just the user login.
803
804     unsigned end = m_userEnd;
805     if (!user.isEmpty()) {
806         String u = encodeWithURLEscapeSequences(user, PercentEncodeUsername);
807         if (m_userStart == m_schemeEnd + 1)
808             u = "//" + u;
809         // Add '@' if we didn't have one before.
810         if (end == m_hostEnd || (end == m_passwordEnd && m_string[end] != '@'))
811             u.append('@');
812         URLParser parser(makeString(m_string.left(m_userStart), u, m_string.substring(end)));
813         *this = parser.result();
814     } else {
815         // Remove '@' if we now have neither user nor password.
816         if (m_userEnd == m_passwordEnd && end != m_hostEnd && m_string[end] == '@')
817             end += 1;
818         // We don't want to parse in the extremely common case where we are not going to make a change.
819         if (m_userStart != end) {
820             URLParser parser(makeString(m_string.left(m_userStart), m_string.substring(end)));
821             *this = parser.result();
822         }
823     }
824 }
825
826 void URL::setPass(const String& password)
827 {
828     if (!m_isValid)
829         return;
830
831     unsigned end = m_passwordEnd;
832     if (!password.isEmpty()) {
833         String p = ":" + encodeWithURLEscapeSequences(password, PercentEncodePassword) + "@";
834         if (m_userEnd == m_schemeEnd + 1)
835             p = "//" + p;
836         // Eat the existing '@' since we are going to add our own.
837         if (end != m_hostEnd && m_string[end] == '@')
838             end += 1;
839         URLParser parser(makeString(m_string.left(m_userEnd), p, m_string.substring(end)));
840         *this = parser.result();
841     } else {
842         // Remove '@' if we now have neither user nor password.
843         if (m_userStart == m_userEnd && end != m_hostEnd && m_string[end] == '@')
844             end += 1;
845         // We don't want to parse in the extremely common case where we are not going to make a change.
846         if (m_userEnd != end) {
847             URLParser parser(makeString(m_string.left(m_userEnd), m_string.substring(end)));
848             *this = parser.result();
849         }
850     }
851 }
852
853 void URL::setFragmentIdentifier(StringView identifier)
854 {
855     if (!m_isValid)
856         return;
857
858     // FIXME: Optimize the case where the identifier already happens to be equal to what was passed?
859     // FIXME: Is it correct to do this without encoding and escaping non-ASCII characters?
860     *this = URLParser { makeString(StringView { m_string }.substring(0, m_queryEnd), '#', identifier) }.result();
861 }
862
863 void URL::removeFragmentIdentifier()
864 {
865     if (!m_isValid) {
866         ASSERT(!m_queryEnd);
867         return;
868     }
869     if (m_isValid && m_string.length() > m_queryEnd)
870         m_string = m_string.left(m_queryEnd);
871 }
872     
873 void URL::setQuery(const String& query)
874 {
875     if (!m_isValid)
876         return;
877
878     // FIXME: '#' and non-ASCII characters must be encoded and escaped.
879     // Usually, the query is encoded using document encoding, not UTF-8, but we don't have
880     // access to the document in this function.
881     // https://webkit.org/b/161176
882     if ((query.isEmpty() || query[0] != '?') && !query.isNull()) {
883         URLParser parser(makeString(m_string.left(m_pathEnd), "?", query, m_string.substring(m_queryEnd)));
884         *this = parser.result();
885     } else {
886         URLParser parser(makeString(m_string.left(m_pathEnd), query, m_string.substring(m_queryEnd)));
887         *this = parser.result();
888     }
889
890 }
891
892 void URL::setPath(const String& s)
893 {
894     if (!m_isValid)
895         return;
896
897     // FIXME: encodeWithURLEscapeSequences does not correctly escape '#' and '?', so fragment and query parts
898     // may be inadvertently affected.
899     String path = s;
900     if (path.isEmpty() || path[0] != '/')
901         path = "/" + path;
902
903     URLParser parser(makeString(m_string.left(m_portEnd), encodeWithURLEscapeSequences(path), m_string.substring(m_pathEnd)));
904     *this = parser.result();
905 }
906
907 String decodeURLEscapeSequences(const String& string)
908 {
909     return decodeEscapeSequences<URLEscapeSequence>(string, UTF8Encoding());
910 }
911
912 String decodeURLEscapeSequences(const String& string, const TextEncoding& encoding)
913 {
914     return decodeEscapeSequences<URLEscapeSequence>(string, encoding);
915 }
916
917 // Caution: This function does not bounds check.
918 static void appendEscapedChar(char*& buffer, unsigned char c)
919 {
920     *buffer++ = '%';
921     placeByteAsHex(c, buffer);
922 }
923
924 String URL::serialize(bool omitFragment) const
925 {
926     if (omitFragment)
927         return m_string.left(m_queryEnd);
928     return m_string;
929 }
930
931 #if PLATFORM(IOS)
932
933 static bool shouldCanonicalizeScheme = true;
934
935 void enableURLSchemeCanonicalization(bool enableSchemeCanonicalization)
936 {
937     shouldCanonicalizeScheme = enableSchemeCanonicalization;
938 }
939
940 #endif
941
942 template<size_t length>
943 static inline bool equal(const char* a, const char (&b)[length])
944 {
945 #if PLATFORM(IOS)
946     if (!shouldCanonicalizeScheme) {
947         for (size_t i = 0; i < length; ++i) {
948             if (toASCIILower(a[i]) != b[i])
949                 return false;
950         }
951         return true;
952     }
953 #endif
954     for (size_t i = 0; i < length; ++i) {
955         if (a[i] != b[i])
956             return false;
957     }
958     return true;
959 }
960
961 template<size_t lengthB>
962 static inline bool equal(const char* stringA, size_t lengthA, const char (&stringB)[lengthB])
963 {
964     return lengthA == lengthB && equal(stringA, stringB);
965 }
966
967 bool equalIgnoringFragmentIdentifier(const URL& a, const URL& b)
968 {
969     if (a.m_queryEnd != b.m_queryEnd)
970         return false;
971     unsigned queryLength = a.m_queryEnd;
972     for (unsigned i = 0; i < queryLength; ++i)
973         if (a.string()[i] != b.string()[i])
974             return false;
975     return true;
976 }
977
978 bool protocolHostAndPortAreEqual(const URL& a, const URL& b)
979 {
980     if (a.m_schemeEnd != b.m_schemeEnd)
981         return false;
982
983     unsigned hostStartA = a.hostStart();
984     unsigned hostLengthA = a.hostEnd() - hostStartA;
985     unsigned hostStartB = b.hostStart();
986     unsigned hostLengthB = b.hostEnd() - b.hostStart();
987     if (hostLengthA != hostLengthB)
988         return false;
989
990     // Check the scheme
991     for (unsigned i = 0; i < a.m_schemeEnd; ++i) {
992         if (a.string()[i] != b.string()[i])
993             return false;
994     }
995
996     // And the host
997     for (unsigned i = 0; i < hostLengthA; ++i) {
998         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
999             return false;
1000     }
1001
1002     if (a.port() != b.port())
1003         return false;
1004
1005     return true;
1006 }
1007
1008 bool hostsAreEqual(const URL& a, const URL& b)
1009 {
1010     unsigned hostStartA = a.hostStart();
1011     unsigned hostLengthA = a.hostEnd() - hostStartA;
1012     unsigned hostStartB = b.hostStart();
1013     unsigned hostLengthB = b.hostEnd() - hostStartB;
1014     if (hostLengthA != hostLengthB)
1015         return false;
1016
1017     for (unsigned i = 0; i < hostLengthA; ++i) {
1018         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
1019             return false;
1020     }
1021
1022     return true;
1023 }
1024
1025 String encodeWithURLEscapeSequences(const String& notEncodedString, PercentEncodeCharacterClass whatToEncode)
1026 {
1027     CString asUTF8 = notEncodedString.utf8();
1028
1029     CharBuffer buffer(asUTF8.length() * 3 + 1);
1030     char* p = buffer.data();
1031
1032     const char* str = asUTF8.data();
1033     const char* strEnd = str + asUTF8.length();
1034     while (str < strEnd) {
1035         unsigned char c = *str++;
1036         if (percentEncodeClassTable[c] >= whatToEncode)
1037             appendEscapedChar(p, c);
1038         else
1039             *p++ = c;
1040     }
1041
1042     ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
1043
1044     return String(buffer.data(), p - buffer.data());
1045 }
1046
1047 String encodeWithURLEscapeSequences(const String& notEncodedString)
1048 {
1049     CString asUTF8 = notEncodedString.utf8();
1050
1051     CharBuffer buffer(asUTF8.length() * 3 + 1);
1052     char* p = buffer.data();
1053
1054     const char* str = asUTF8.data();
1055     const char* strEnd = str + asUTF8.length();
1056     while (str < strEnd) {
1057         unsigned char c = *str++;
1058         if (isBadChar(c))
1059             appendEscapedChar(p, c);
1060         else
1061             *p++ = c;
1062     }
1063
1064     ASSERT(p - buffer.data() <= static_cast<int>(buffer.size()));
1065
1066     return String(buffer.data(), p - buffer.data());
1067 }
1068
1069 bool URL::isHierarchical() const
1070 {
1071     if (!m_isValid)
1072         return false;
1073     ASSERT(m_string[m_schemeEnd] == ':');
1074     return m_string[m_schemeEnd + 1] == '/';
1075 }
1076
1077 void URL::copyToBuffer(Vector<char, 512>& buffer) const
1078 {
1079     // FIXME: This throws away the high bytes of all the characters in the string!
1080     // That's fine for a valid URL, which is all ASCII, but not for invalid URLs.
1081     buffer.resize(m_string.length());
1082     copyASCII(m_string, buffer.data());
1083 }
1084
1085 template<typename StringClass>
1086 bool protocolIsInternal(const StringClass& url, const char* protocol)
1087 {
1088     // Do the comparison without making a new string object.
1089     assertProtocolIsGood(StringView(reinterpret_cast<const LChar*>(protocol), strlen(protocol)));
1090     bool isLeading = true;
1091     for (unsigned i = 0, j = 0; url[i]; ++i) {
1092         // Skip leading whitespace and control characters.
1093         if (isLeading && shouldTrimFromURL(url[i]))
1094             continue;
1095         isLeading = false;
1096
1097         // Skip any tabs and newlines.
1098         if (isTabNewline(url[i]))
1099             continue;
1100
1101         if (!protocol[j])
1102             return url[i] == ':';
1103         if (!isASCIIAlphaCaselessEqual(url[i], protocol[j]))
1104             return false;
1105
1106         ++j;
1107     }
1108     
1109     return false;
1110 }
1111
1112 bool protocolIs(const String& url, const char* protocol)
1113 {
1114     return protocolIsInternal(url, protocol);
1115 }
1116
1117 inline bool URL::protocolIs(const String& string, const char* protocol)
1118 {
1119     return WebCore::protocolIsInternal(string, protocol);
1120 }
1121
1122 bool isValidProtocol(const String& protocol)
1123 {
1124     // RFC3986: ALPHA *( ALPHA / DIGIT / "+" / "-" / "." )
1125     if (protocol.isEmpty())
1126         return false;
1127     if (!isSchemeFirstChar(protocol[0]))
1128         return false;
1129     unsigned protocolLength = protocol.length();
1130     for (unsigned i = 1; i < protocolLength; i++) {
1131         if (!isSchemeChar(protocol[i]))
1132             return false;
1133     }
1134     return true;
1135 }
1136
1137 #ifndef NDEBUG
1138
1139 void URL::print() const
1140 {
1141     printf("%s\n", m_string.utf8().data());
1142 }
1143
1144 #endif
1145
1146 String URL::strippedForUseAsReferrer() const
1147 {
1148     URL referrer(*this);
1149     referrer.setUser(String());
1150     referrer.setPass(String());
1151     referrer.removeFragmentIdentifier();
1152     return referrer.string();
1153 }
1154
1155 bool URL::isLocalFile() const
1156 {
1157     // Including feed here might be a bad idea since drag and drop uses this check
1158     // and including feed would allow feeds to potentially let someone's blog
1159     // read the contents of the clipboard on a drag, even without a drop.
1160     // Likewise with using the FrameLoader::shouldTreatURLAsLocal() function.
1161     return protocolIs("file");
1162 }
1163
1164 bool protocolIsJavaScript(const String& url)
1165 {
1166     return protocolIsInternal(url, "javascript");
1167 }
1168
1169 bool protocolIsJavaScript(StringView url)
1170 {
1171     return protocolIsInternal(url, "javascript");
1172 }
1173
1174 bool protocolIsInHTTPFamily(const String& url)
1175 {
1176     // Do the comparison without making a new string object.
1177     return isASCIIAlphaCaselessEqual(url[0], 'h')
1178         && isASCIIAlphaCaselessEqual(url[1], 't')
1179         && isASCIIAlphaCaselessEqual(url[2], 't')
1180         && isASCIIAlphaCaselessEqual(url[3], 'p')
1181         && (url[4] == ':' || (isASCIIAlphaCaselessEqual(url[4], 's') && url[5] == ':'));
1182 }
1183
1184 const URL& blankURL()
1185 {
1186     static NeverDestroyed<URL> staticBlankURL(ParsedURLString, "about:blank");
1187     return staticBlankURL;
1188 }
1189
1190 bool URL::isBlankURL() const
1191 {
1192     return protocolIs("about");
1193 }
1194
1195 bool portAllowed(const URL& url)
1196 {
1197     std::optional<uint16_t> port = url.port();
1198
1199     // Since most URLs don't have a port, return early for the "no port" case.
1200     if (!port)
1201         return true;
1202
1203     // This blocked port list matches the port blocking that Mozilla implements.
1204     // See http://www.mozilla.org/projects/netlib/PortBanning.html for more information.
1205     static const uint16_t blockedPortList[] = {
1206         1,    // tcpmux
1207         7,    // echo
1208         9,    // discard
1209         11,   // systat
1210         13,   // daytime
1211         15,   // netstat
1212         17,   // qotd
1213         19,   // chargen
1214         20,   // FTP-data
1215         21,   // FTP-control
1216         22,   // SSH
1217         23,   // telnet
1218         25,   // SMTP
1219         37,   // time
1220         42,   // name
1221         43,   // nicname
1222         53,   // domain
1223         77,   // priv-rjs
1224         79,   // finger
1225         87,   // ttylink
1226         95,   // supdup
1227         101,  // hostriame
1228         102,  // iso-tsap
1229         103,  // gppitnp
1230         104,  // acr-nema
1231         109,  // POP2
1232         110,  // POP3
1233         111,  // sunrpc
1234         113,  // auth
1235         115,  // SFTP
1236         117,  // uucp-path
1237         119,  // nntp
1238         123,  // NTP
1239         135,  // loc-srv / epmap
1240         139,  // netbios
1241         143,  // IMAP2
1242         179,  // BGP
1243         389,  // LDAP
1244         465,  // SMTP+SSL
1245         512,  // print / exec
1246         513,  // login
1247         514,  // shell
1248         515,  // printer
1249         526,  // tempo
1250         530,  // courier
1251         531,  // Chat
1252         532,  // netnews
1253         540,  // UUCP
1254         556,  // remotefs
1255         563,  // NNTP+SSL
1256         587,  // ESMTP
1257         601,  // syslog-conn
1258         636,  // LDAP+SSL
1259         993,  // IMAP+SSL
1260         995,  // POP3+SSL
1261         2049, // NFS
1262         3659, // apple-sasl / PasswordServer [Apple addition]
1263         4045, // lockd
1264         4190, // ManageSieve [Apple addition]
1265         6000, // X11
1266         6665, // Alternate IRC [Apple addition]
1267         6666, // Alternate IRC [Apple addition]
1268         6667, // Standard IRC [Apple addition]
1269         6668, // Alternate IRC [Apple addition]
1270         6669, // Alternate IRC [Apple addition]
1271         invalidPortNumber, // Used to block all invalid port numbers
1272     };
1273
1274     // If the port is not in the blocked port list, allow it.
1275     ASSERT(std::is_sorted(std::begin(blockedPortList), std::end(blockedPortList)));
1276     if (!std::binary_search(std::begin(blockedPortList), std::end(blockedPortList), port.value()))
1277         return true;
1278
1279     // Allow ports 21 and 22 for FTP URLs, as Mozilla does.
1280     if ((port.value() == 21 || port.value() == 22) && url.protocolIs("ftp"))
1281         return true;
1282
1283     // Allow any port number in a file URL, since the port number is ignored.
1284     if (url.protocolIs("file"))
1285         return true;
1286
1287     return false;
1288 }
1289
1290 String mimeTypeFromDataURL(const String& url)
1291 {
1292     ASSERT(protocolIsInternal(url, "data"));
1293
1294     // FIXME: What's the right behavior when the URL has a comma first, but a semicolon later?
1295     // Currently this code will break at the semicolon in that case. Not sure that's correct.
1296     auto index = url.find(';', 5);
1297     if (index == notFound)
1298         index = url.find(',', 5);
1299     if (index == notFound) {
1300         // FIXME: There was an old comment here that made it sound like this should be returning text/plain.
1301         // But we have been returning empty string here for some time, so not changing its behavior at this time.
1302         return emptyString();
1303     }
1304     if (index == 5)
1305         return ASCIILiteral("text/plain");
1306     ASSERT(index >= 5);
1307     return url.substring(5, index - 5).convertToASCIILowercase();
1308 }
1309
1310 String mimeTypeFromURL(const URL& url)
1311 {
1312     String decodedPath = decodeURLEscapeSequences(url.path());
1313     String extension = decodedPath.substring(decodedPath.reverseFind('.') + 1);
1314
1315     // We don't use MIMETypeRegistry::getMIMETypeForPath() because it returns "application/octet-stream" upon failure
1316     return MIMETypeRegistry::getMIMETypeForExtension(extension);
1317 }
1318
1319 String URL::stringCenterEllipsizedToLength(unsigned length) const
1320 {
1321     if (string().length() <= length)
1322         return string();
1323
1324     return string().left(length / 2 - 1) + "..." + string().right(length / 2 - 2);
1325 }
1326
1327 URL URL::fakeURLWithRelativePart(const String& relativePart)
1328 {
1329     return URL(URL(), "webkit-fake-url://" + createCanonicalUUIDString() + '/' + relativePart);
1330 }
1331
1332 URL URL::fileURLWithFileSystemPath(const String& filePath)
1333 {
1334     return URL(URL(), "file:///" + filePath);
1335 }
1336
1337 }