cb66916f23e4c1324186cd8270e828b14973498b
[WebKit-https.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 "TextEncoding.h"
32 #include "URLParser.h"
33 #include <stdio.h>
34 #include <unicode/uidna.h>
35 #include <wtf/HashMap.h>
36 #include <wtf/HexNumber.h>
37 #include <wtf/NeverDestroyed.h>
38 #include <wtf/StdLibExtras.h>
39 #include <wtf/UUID.h>
40 #include <wtf/text/CString.h>
41 #include <wtf/text/StringBuilder.h>
42 #include <wtf/text/StringConcatenateNumbers.h>
43 #include <wtf/text/StringHash.h>
44 #include <wtf/text/TextStream.h>
45
46 // FIXME: This file makes too much use of the + operator on String.
47 // We either have to optimize that operator so it doesn't involve
48 // so many allocations, or change this to use StringBuffer instead.
49
50
51 namespace WebCore {
52 using namespace WTF;
53
54 typedef Vector<char, 512> CharBuffer;
55 typedef Vector<UChar, 512> UCharBuffer;
56
57 static const unsigned invalidPortNumber = 0xFFFF;
58
59 // Copies the source to the destination, assuming all the source characters are
60 // ASCII. The destination buffer must be large enough. Null characters are allowed
61 // in the source string, and no attempt is made to null-terminate the result.
62 static void copyASCII(const String& string, char* dest)
63 {
64     if (string.isEmpty())
65         return;
66
67     if (string.is8Bit())
68         memcpy(dest, string.characters8(), string.length());
69     else {
70         const UChar* src = string.characters16();
71         size_t length = string.length();
72         for (size_t i = 0; i < length; i++)
73             dest[i] = static_cast<char>(src[i]);
74     }
75 }
76
77 void URL::invalidate()
78 {
79     m_isValid = false;
80     m_protocolIsInHTTPFamily = false;
81     m_cannotBeABaseURL = false;
82     m_schemeEnd = 0;
83     m_userStart = 0;
84     m_userEnd = 0;
85     m_passwordEnd = 0;
86     m_hostEnd = 0;
87     m_portEnd = 0;
88     m_pathEnd = 0;
89     m_pathAfterLastSlash = 0;
90     m_queryEnd = 0;
91 }
92
93 URL::URL(ParsedURLStringTag, const String& url)
94 {
95     URLParser parser(url);
96     *this = parser.result();
97
98 #if OS(WINDOWS)
99     // FIXME(148598): Work around Windows local file handling bug in CFNetwork
100     ASSERT(isLocalFile() || url == m_string);
101 #else
102     ASSERT(url == m_string);
103 #endif
104 }
105
106 URL::URL(const URL& base, const String& relative)
107 {
108     URLParser parser(relative, base);
109     *this = parser.result();
110 }
111
112 URL::URL(const URL& base, const String& relative, const TextEncoding& encoding)
113 {
114     // For UTF-{7,16,32}, we want to use UTF-8 for the query part as
115     // we do when submitting a form. A form with GET method
116     // has its contents added to a URL as query params and it makes sense
117     // to be consistent.
118     URLParser parser(relative, base, encoding.encodingForFormSubmission());
119     *this = parser.result();
120 }
121
122 static bool shouldTrimFromURL(UChar c)
123 {
124     // Browsers ignore leading/trailing whitespace and control
125     // characters from URLs.  Note that c is an *unsigned* char here
126     // so this comparison should only catch control characters.
127     return c <= ' ';
128 }
129
130 URL URL::isolatedCopy() const
131 {
132     URL result = *this;
133     result.m_string = result.m_string.isolatedCopy();
134     return result;
135 }
136
137 String URL::lastPathComponent() const
138 {
139     if (!hasPath())
140         return String();
141
142     unsigned end = m_pathEnd - 1;
143     if (m_string[end] == '/')
144         --end;
145
146     size_t start = m_string.reverseFind('/', end);
147     if (start < static_cast<unsigned>(m_portEnd))
148         return String();
149     ++start;
150
151     return m_string.substring(start, end - start + 1);
152 }
153
154 StringView URL::protocol() const
155 {
156     return StringView(m_string).substring(0, m_schemeEnd);
157 }
158
159 StringView URL::host() const
160 {
161     unsigned start = hostStart();
162     return StringView(m_string).substring(start, m_hostEnd - start);
163 }
164
165 std::optional<uint16_t> URL::port() const
166 {
167     if (!m_portEnd || m_hostEnd >= m_portEnd - 1)
168         return std::nullopt;
169
170     bool ok = false;
171     unsigned number;
172     if (m_string.is8Bit())
173         number = charactersToUIntStrict(m_string.characters8() + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
174     else
175         number = charactersToUIntStrict(m_string.characters16() + m_hostEnd + 1, m_portEnd - m_hostEnd - 1, &ok);
176     if (!ok || number > std::numeric_limits<uint16_t>::max())
177         return std::nullopt;
178     return number;
179 }
180
181 String URL::hostAndPort() const
182 {
183     if (auto port = this->port())
184         return makeString(host(), ':', static_cast<unsigned>(port.value()));
185     return host().toString();
186 }
187
188 String URL::protocolHostAndPort() const
189 {
190     String result = m_string.substring(0, m_portEnd);
191
192     if (m_passwordEnd - m_userStart > 0) {
193         const int allowForTrailingAtSign = 1;
194         result.remove(m_userStart, m_passwordEnd - m_userStart + allowForTrailingAtSign);
195     }
196
197     return result;
198 }
199
200 String URL::user() const
201 {
202     return decodeURLEscapeSequences(m_string.substring(m_userStart, m_userEnd - m_userStart));
203 }
204
205 String URL::pass() const
206 {
207     if (m_passwordEnd == m_userEnd)
208         return String();
209
210     return decodeURLEscapeSequences(m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1));
211 }
212
213 String URL::encodedUser() const
214 {
215     return m_string.substring(m_userStart, m_userEnd - m_userStart);
216 }
217
218 String URL::encodedPass() const
219 {
220     if (m_passwordEnd == m_userEnd)
221         return String();
222
223     return m_string.substring(m_userEnd + 1, m_passwordEnd - m_userEnd - 1);
224 }
225
226 String URL::fragmentIdentifier() const
227 {
228     if (!hasFragmentIdentifier())
229         return String();
230
231     return m_string.substring(m_queryEnd + 1);
232 }
233
234 bool URL::hasFragmentIdentifier() const
235 {
236     return m_isValid && m_string.length() != m_queryEnd;
237 }
238
239 String URL::baseAsString() const
240 {
241     return m_string.left(m_pathAfterLastSlash);
242 }
243
244 #if !USE(CF)
245
246 String URL::fileSystemPath() const
247 {
248     if (!isValid() || !isLocalFile())
249         return String();
250
251     return decodeURLEscapeSequences(path());
252 }
253
254 #endif
255
256 #ifdef NDEBUG
257
258 static inline void assertProtocolIsGood(StringView)
259 {
260 }
261
262 #else
263
264 static void assertProtocolIsGood(StringView protocol)
265 {
266     // FIXME: We probably don't need this function any more.
267     // The isASCIIAlphaCaselessEqual function asserts that passed-in characters
268     // are ones it can handle; the older code did not and relied on these checks.
269     for (auto character : protocol.codeUnits()) {
270         ASSERT(isASCII(character));
271         ASSERT(character > ' ');
272         ASSERT(!isASCIIUpper(character));
273         ASSERT(toASCIILowerUnchecked(character) == character);
274     }
275 }
276
277 #endif
278
279 static Lock defaultPortForProtocolMapForTestingLock;
280
281 using DefaultPortForProtocolMapForTesting = HashMap<String, uint16_t>;
282 static DefaultPortForProtocolMapForTesting*& defaultPortForProtocolMapForTesting()
283 {
284     static DefaultPortForProtocolMapForTesting* defaultPortForProtocolMap;
285     return defaultPortForProtocolMap;
286 }
287
288 static DefaultPortForProtocolMapForTesting& ensureDefaultPortForProtocolMapForTesting()
289 {
290     DefaultPortForProtocolMapForTesting*& defaultPortForProtocolMap = defaultPortForProtocolMapForTesting();
291     if (!defaultPortForProtocolMap)
292         defaultPortForProtocolMap = new DefaultPortForProtocolMapForTesting;
293     return *defaultPortForProtocolMap;
294 }
295
296 void registerDefaultPortForProtocolForTesting(uint16_t port, const String& protocol)
297 {
298     auto locker = holdLock(defaultPortForProtocolMapForTestingLock);
299     ensureDefaultPortForProtocolMapForTesting().add(protocol, port);
300 }
301
302 void clearDefaultPortForProtocolMapForTesting()
303 {
304     auto locker = holdLock(defaultPortForProtocolMapForTestingLock);
305     if (auto* map = defaultPortForProtocolMapForTesting())
306         map->clear();
307 }
308
309 std::optional<uint16_t> defaultPortForProtocol(StringView protocol)
310 {
311     if (auto* overrideMap = defaultPortForProtocolMapForTesting()) {
312         auto locker = holdLock(defaultPortForProtocolMapForTestingLock);
313         ASSERT(overrideMap); // No need to null check again here since overrideMap cannot become null after being non-null.
314         auto iterator = overrideMap->find(protocol.toStringWithoutCopying());
315         if (iterator != overrideMap->end())
316             return iterator->value;
317     }
318     return URLParser::defaultPortForProtocol(protocol);
319 }
320
321 bool isDefaultPortForProtocol(uint16_t port, StringView protocol)
322 {
323     return defaultPortForProtocol(protocol) == port;
324 }
325
326 bool URL::protocolIs(const char* protocol) const
327 {
328     assertProtocolIsGood(StringView(reinterpret_cast<const LChar*>(protocol), strlen(protocol)));
329
330     // JavaScript URLs are "valid" and should be executed even if URL decides they are invalid.
331     // The free function protocolIsJavaScript() should be used instead. 
332     ASSERT(!equalLettersIgnoringASCIICase(StringView(protocol), "javascript"));
333
334     if (!m_isValid)
335         return false;
336
337     // Do the comparison without making a new string object.
338     for (unsigned i = 0; i < m_schemeEnd; ++i) {
339         if (!protocol[i] || !isASCIIAlphaCaselessEqual(m_string[i], protocol[i]))
340             return false;
341     }
342     return !protocol[m_schemeEnd]; // We should have consumed all characters in the argument.
343 }
344
345 bool URL::protocolIs(StringView protocol) const
346 {
347     assertProtocolIsGood(protocol);
348
349     if (!m_isValid)
350         return false;
351     
352     if (m_schemeEnd != protocol.length())
353         return false;
354
355     // Do the comparison without making a new string object.
356     for (unsigned i = 0; i < m_schemeEnd; ++i) {
357         if (!isASCIIAlphaCaselessEqual(m_string[i], protocol[i]))
358             return false;
359     }
360     return true;
361 }
362
363 String URL::query() const
364 {
365     if (m_queryEnd == m_pathEnd)
366         return String();
367
368     return m_string.substring(m_pathEnd + 1, m_queryEnd - (m_pathEnd + 1)); 
369 }
370
371 String URL::path() const
372 {
373     return m_string.substring(m_portEnd, m_pathEnd - m_portEnd);
374 }
375
376 bool URL::setProtocol(const String& s)
377 {
378     // Firefox and IE remove everything after the first ':'.
379     size_t separatorPosition = s.find(':');
380     String newProtocol = s.substring(0, separatorPosition);
381     auto canonicalized = URLParser::maybeCanonicalizeScheme(newProtocol);
382     if (!canonicalized)
383         return false;
384
385     if (!m_isValid) {
386         URLParser parser(makeString(*canonicalized, ":", m_string));
387         *this = parser.result();
388         return true;
389     }
390
391     URLParser parser(makeString(*canonicalized, m_string.substring(m_schemeEnd)));
392     *this = parser.result();
393     return true;
394 }
395
396 static bool isAllASCII(StringView string)
397 {
398     if (string.is8Bit())
399         return charactersAreAllASCII(string.characters8(), string.length());
400     return charactersAreAllASCII(string.characters16(), string.length());
401 }
402     
403 // Appends the punycoded hostname identified by the given string and length to
404 // the output buffer. The result will not be null terminated.
405 // Return value of false means error in encoding.
406 static bool appendEncodedHostname(UCharBuffer& buffer, StringView string)
407 {
408     // Needs to be big enough to hold an IDN-encoded name.
409     // For host names bigger than this, we won't do IDN encoding, which is almost certainly OK.
410     const unsigned hostnameBufferLength = 2048;
411     
412     if (string.length() > hostnameBufferLength || isAllASCII(string)) {
413         append(buffer, string);
414         return true;
415     }
416     
417     UChar hostnameBuffer[hostnameBufferLength];
418     UErrorCode error = U_ZERO_ERROR;
419     UIDNAInfo processingDetails = UIDNA_INFO_INITIALIZER;
420     int32_t numCharactersConverted = uidna_nameToASCII(&URLParser::internationalDomainNameTranscoder(),
421         string.upconvertedCharacters(), string.length(), hostnameBuffer, hostnameBufferLength, &processingDetails, &error);
422     
423     if (U_SUCCESS(error) && !processingDetails.errors) {
424         buffer.append(hostnameBuffer, numCharactersConverted);
425         return true;
426     }
427     return false;
428 }
429     
430 void URL::setHost(const String& s)
431 {
432     if (!m_isValid)
433         return;
434
435     auto colonIndex = s.find(':');
436     if (colonIndex != notFound)
437         return;
438
439     UCharBuffer encodedHostName;
440     if (!appendEncodedHostname(encodedHostName, s))
441         return;
442     
443     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
444     
445     StringBuilder builder;
446     builder.append(m_string.left(hostStart()));
447     if (slashSlashNeeded)
448         builder.appendLiteral("//");
449     builder.append(StringView(encodedHostName.data(), encodedHostName.size()));
450     builder.append(m_string.substring(m_hostEnd));
451
452     URLParser parser(builder.toString());
453     *this = parser.result();
454 }
455
456 void URL::removePort()
457 {
458     if (m_hostEnd == m_portEnd)
459         return;
460     URLParser parser(m_string.left(m_hostEnd) + m_string.substring(m_portEnd));
461     *this = parser.result();
462 }
463
464 void URL::setPort(unsigned short i)
465 {
466     if (!m_isValid)
467         return;
468
469     bool colonNeeded = m_portEnd == m_hostEnd;
470     unsigned portStart = (colonNeeded ? m_hostEnd : m_hostEnd + 1);
471
472     URLParser parser(makeString(m_string.left(portStart), (colonNeeded ? ":" : ""), String::number(i), m_string.substring(m_portEnd)));
473     *this = parser.result();
474 }
475
476 void URL::setHostAndPort(const String& hostAndPort)
477 {
478     if (!m_isValid)
479         return;
480
481     StringView hostName(hostAndPort);
482     StringView port;
483     
484     auto colonIndex = hostName.find(':');
485     if (colonIndex != notFound) {
486         port = hostName.substring(colonIndex + 1);
487         bool ok;
488         int portInt = port.toIntStrict(ok);
489         if (!ok || portInt < 0)
490             return;
491         hostName = hostName.substring(0, colonIndex);
492     }
493
494     if (hostName.isEmpty())
495         return;
496
497     UCharBuffer encodedHostName;
498     if (!appendEncodedHostname(encodedHostName, hostName))
499         return;
500
501     bool slashSlashNeeded = m_userStart == m_schemeEnd + 1;
502
503     StringBuilder builder;
504     builder.append(m_string.left(hostStart()));
505     if (slashSlashNeeded)
506         builder.appendLiteral("//");
507     builder.append(StringView(encodedHostName.data(), encodedHostName.size()));
508     if (!port.isEmpty()) {
509         builder.appendLiteral(":");
510         builder.append(port);
511     }
512     builder.append(m_string.substring(m_portEnd));
513
514     URLParser parser(builder.toString());
515     *this = parser.result();
516 }
517
518 static String percentEncodeCharacters(const String& input, bool(*shouldEncode)(UChar))
519 {
520     auto encode = [shouldEncode] (const String& input) {
521         CString utf8 = input.utf8();
522         auto* data = utf8.data();
523         StringBuilder builder;
524         auto length = utf8.length();
525         for (unsigned j = 0; j < length; j++) {
526             auto c = data[j];
527             if (shouldEncode(c)) {
528                 builder.append('%');
529                 builder.append(upperNibbleToASCIIHexDigit(c));
530                 builder.append(lowerNibbleToASCIIHexDigit(c));
531             } else
532                 builder.append(c);
533         }
534         return builder.toString();
535     };
536
537     for (size_t i = 0; i < input.length(); ++i) {
538         if (UNLIKELY(shouldEncode(input[i])))
539             return encode(input);
540     }
541     return input;
542 }
543
544 void URL::setUser(const String& user)
545 {
546     if (!m_isValid)
547         return;
548
549     // FIXME: Non-ASCII characters must be encoded and escaped to match parse() expectations,
550     // and to avoid changing more than just the user login.
551
552     unsigned end = m_userEnd;
553     if (!user.isEmpty()) {
554         String u = percentEncodeCharacters(user, URLParser::isInUserInfoEncodeSet);
555         if (m_userStart == m_schemeEnd + 1)
556             u = "//" + u;
557         // Add '@' if we didn't have one before.
558         if (end == m_hostEnd || (end == m_passwordEnd && m_string[end] != '@'))
559             u.append('@');
560         URLParser parser(makeString(StringView(m_string).left(m_userStart), u, StringView(m_string).substring(end)));
561         *this = parser.result();
562     } else {
563         // Remove '@' if we now have neither user nor password.
564         if (m_userEnd == m_passwordEnd && end != m_hostEnd && m_string[end] == '@')
565             end += 1;
566         // We don't want to parse in the extremely common case where we are not going to make a change.
567         if (m_userStart != end) {
568             URLParser parser(makeString(StringView(m_string).left(m_userStart), StringView(m_string).substring(end)));
569             *this = parser.result();
570         }
571     }
572 }
573
574 void URL::setPass(const String& password)
575 {
576     if (!m_isValid)
577         return;
578
579     unsigned end = m_passwordEnd;
580     if (!password.isEmpty()) {
581         String p = ":" + percentEncodeCharacters(password, URLParser::isInUserInfoEncodeSet) + "@";
582         if (m_userEnd == m_schemeEnd + 1)
583             p = "//" + p;
584         // Eat the existing '@' since we are going to add our own.
585         if (end != m_hostEnd && m_string[end] == '@')
586             end += 1;
587         URLParser parser(makeString(StringView(m_string).left(m_userEnd), p, StringView(m_string).substring(end)));
588         *this = parser.result();
589     } else {
590         // Remove '@' if we now have neither user nor password.
591         if (m_userStart == m_userEnd && end != m_hostEnd && m_string[end] == '@')
592             end += 1;
593         // We don't want to parse in the extremely common case where we are not going to make a change.
594         if (m_userEnd != end) {
595             URLParser parser(makeString(StringView(m_string).left(m_userEnd), StringView(m_string).substring(end)));
596             *this = parser.result();
597         }
598     }
599 }
600
601 void URL::setFragmentIdentifier(StringView identifier)
602 {
603     if (!m_isValid)
604         return;
605
606     // FIXME: Optimize the case where the identifier already happens to be equal to what was passed?
607     // FIXME: Is it correct to do this without encoding and escaping non-ASCII characters?
608     *this = URLParser { makeString(StringView { m_string }.substring(0, m_queryEnd), '#', identifier) }.result();
609 }
610
611 void URL::removeFragmentIdentifier()
612 {
613     if (!m_isValid) {
614         ASSERT(!m_queryEnd);
615         return;
616     }
617     if (m_isValid && m_string.length() > m_queryEnd)
618         m_string = m_string.left(m_queryEnd);
619 }
620
621 void URL::removeQueryAndFragmentIdentifier()
622 {
623     if (!m_isValid)
624         return;
625
626     m_string = m_string.left(m_pathEnd);
627     m_queryEnd = m_pathEnd;
628 }
629
630 void URL::setQuery(const String& query)
631 {
632     if (!m_isValid)
633         return;
634
635     // FIXME: '#' and non-ASCII characters must be encoded and escaped.
636     // Usually, the query is encoded using document encoding, not UTF-8, but we don't have
637     // access to the document in this function.
638     // https://webkit.org/b/161176
639     if ((query.isEmpty() || query[0] != '?') && !query.isNull()) {
640         URLParser parser(makeString(StringView(m_string).left(m_pathEnd), "?", query, StringView(m_string).substring(m_queryEnd)));
641         *this = parser.result();
642     } else {
643         URLParser parser(makeString(StringView(m_string).left(m_pathEnd), query, StringView(m_string).substring(m_queryEnd)));
644         *this = parser.result();
645     }
646
647 }
648
649 void URL::setPath(const String& s)
650 {
651     if (!m_isValid)
652         return;
653
654     String path = s;
655     if (path.isEmpty() || path[0] != '/')
656         path = "/" + path;
657
658     auto questionMarkOrNumberSign = [] (UChar character) {
659         return character == '?' || character == '#';
660     };
661     URLParser parser(makeString(StringView(m_string).left(m_portEnd), percentEncodeCharacters(path, questionMarkOrNumberSign), StringView(m_string).substring(m_pathEnd)));
662     *this = parser.result();
663 }
664
665 String decodeURLEscapeSequences(const String& string)
666 {
667     if (string.isEmpty())
668         return string;
669     return decodeEscapeSequences<URLEscapeSequence>(string, UTF8Encoding());
670 }
671
672 String decodeURLEscapeSequences(const String& string, const TextEncoding& encoding)
673 {
674     if (string.isEmpty())
675         return string;
676     return decodeEscapeSequences<URLEscapeSequence>(string, encoding);
677 }
678
679 #if PLATFORM(IOS)
680
681 static bool shouldCanonicalizeScheme = true;
682
683 void enableURLSchemeCanonicalization(bool enableSchemeCanonicalization)
684 {
685     shouldCanonicalizeScheme = enableSchemeCanonicalization;
686 }
687
688 #endif
689
690 template<size_t length>
691 static inline bool equal(const char* a, const char (&b)[length])
692 {
693 #if PLATFORM(IOS)
694     if (!shouldCanonicalizeScheme) {
695         for (size_t i = 0; i < length; ++i) {
696             if (toASCIILower(a[i]) != b[i])
697                 return false;
698         }
699         return true;
700     }
701 #endif
702     for (size_t i = 0; i < length; ++i) {
703         if (a[i] != b[i])
704             return false;
705     }
706     return true;
707 }
708
709 template<size_t lengthB>
710 static inline bool equal(const char* stringA, size_t lengthA, const char (&stringB)[lengthB])
711 {
712     return lengthA == lengthB && equal(stringA, stringB);
713 }
714
715 bool equalIgnoringFragmentIdentifier(const URL& a, const URL& b)
716 {
717     if (a.m_queryEnd != b.m_queryEnd)
718         return false;
719     unsigned queryLength = a.m_queryEnd;
720     for (unsigned i = 0; i < queryLength; ++i)
721         if (a.string()[i] != b.string()[i])
722             return false;
723     return true;
724 }
725
726 bool equalIgnoringQueryAndFragment(const URL& a, const URL& b)
727 {
728     if (a.pathEnd() != b.pathEnd())
729         return false;
730     unsigned pathEnd = a.pathEnd();
731     for (unsigned i = 0; i < pathEnd; ++i) {
732         if (a.string()[i] != b.string()[i])
733             return false;
734     }
735     return true;
736 }
737
738 bool protocolHostAndPortAreEqual(const URL& a, const URL& b)
739 {
740     if (a.m_schemeEnd != b.m_schemeEnd)
741         return false;
742
743     unsigned hostStartA = a.hostStart();
744     unsigned hostLengthA = a.hostEnd() - hostStartA;
745     unsigned hostStartB = b.hostStart();
746     unsigned hostLengthB = b.hostEnd() - b.hostStart();
747     if (hostLengthA != hostLengthB)
748         return false;
749
750     // Check the scheme
751     for (unsigned i = 0; i < a.m_schemeEnd; ++i) {
752         if (a.string()[i] != b.string()[i])
753             return false;
754     }
755
756     // And the host
757     for (unsigned i = 0; i < hostLengthA; ++i) {
758         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
759             return false;
760     }
761
762     if (a.port() != b.port())
763         return false;
764
765     return true;
766 }
767
768 bool hostsAreEqual(const URL& a, const URL& b)
769 {
770     unsigned hostStartA = a.hostStart();
771     unsigned hostLengthA = a.hostEnd() - hostStartA;
772     unsigned hostStartB = b.hostStart();
773     unsigned hostLengthB = b.hostEnd() - hostStartB;
774     if (hostLengthA != hostLengthB)
775         return false;
776
777     for (unsigned i = 0; i < hostLengthA; ++i) {
778         if (a.string()[hostStartA + i] != b.string()[hostStartB + i])
779             return false;
780     }
781
782     return true;
783 }
784
785 bool URL::isMatchingDomain(const String& domain) const
786 {
787     if (isNull())
788         return false;
789
790     if (domain.isEmpty())
791         return true;
792
793     if (!protocolIsInHTTPFamily())
794         return false;
795
796     auto host = this->host();
797     if (!host.endsWith(domain))
798         return false;
799
800     return host.length() == domain.length() || host[host.length() - domain.length() - 1] == '.';
801 }
802
803 String encodeWithURLEscapeSequences(const String& input)
804 {
805     return percentEncodeCharacters(input, URLParser::isInUserInfoEncodeSet);
806 }
807
808 bool URL::isHierarchical() const
809 {
810     if (!m_isValid)
811         return false;
812     ASSERT(m_string[m_schemeEnd] == ':');
813     return m_string[m_schemeEnd + 1] == '/';
814 }
815
816 void URL::copyToBuffer(Vector<char, 512>& buffer) const
817 {
818     // FIXME: This throws away the high bytes of all the characters in the string!
819     // That's fine for a valid URL, which is all ASCII, but not for invalid URLs.
820     buffer.resize(m_string.length());
821     copyASCII(m_string, buffer.data());
822 }
823
824 template<typename StringClass>
825 bool protocolIsInternal(const StringClass& url, const char* protocol)
826 {
827     // Do the comparison without making a new string object.
828     assertProtocolIsGood(StringView(reinterpret_cast<const LChar*>(protocol), strlen(protocol)));
829     bool isLeading = true;
830     for (unsigned i = 0, j = 0; url[i]; ++i) {
831         // Skip leading whitespace and control characters.
832         if (isLeading && shouldTrimFromURL(url[i]))
833             continue;
834         isLeading = false;
835
836         // Skip any tabs and newlines.
837         if (url[i] == '\t' || url[i] == '\r' || url[i] == '\n')
838             continue;
839
840         if (!protocol[j])
841             return url[i] == ':';
842         if (!isASCIIAlphaCaselessEqual(url[i], protocol[j]))
843             return false;
844
845         ++j;
846     }
847     
848     return false;
849 }
850
851 bool protocolIs(const String& url, const char* protocol)
852 {
853     return protocolIsInternal(url, protocol);
854 }
855
856 inline bool URL::protocolIs(const String& string, const char* protocol)
857 {
858     return WebCore::protocolIsInternal(string, protocol);
859 }
860
861 #ifndef NDEBUG
862
863 void URL::print() const
864 {
865     printf("%s\n", m_string.utf8().data());
866 }
867
868 #endif
869
870 String URL::strippedForUseAsReferrer() const
871 {
872     URL referrer(*this);
873     referrer.setUser(String());
874     referrer.setPass(String());
875     referrer.removeFragmentIdentifier();
876     return referrer.string();
877 }
878
879 bool URL::isLocalFile() const
880 {
881     // Including feed here might be a bad idea since drag and drop uses this check
882     // and including feed would allow feeds to potentially let someone's blog
883     // read the contents of the clipboard on a drag, even without a drop.
884     // Likewise with using the FrameLoader::shouldTreatURLAsLocal() function.
885     return protocolIs("file");
886 }
887
888 bool protocolIsJavaScript(const String& url)
889 {
890     return protocolIsInternal(url, "javascript");
891 }
892
893 bool protocolIsJavaScript(StringView url)
894 {
895     return protocolIsInternal(url, "javascript");
896 }
897
898 bool protocolIsInHTTPFamily(const String& url)
899 {
900     auto length = url.length();
901     // Do the comparison without making a new string object.
902     return length >= 5
903         && isASCIIAlphaCaselessEqual(url[0], 'h')
904         && isASCIIAlphaCaselessEqual(url[1], 't')
905         && isASCIIAlphaCaselessEqual(url[2], 't')
906         && isASCIIAlphaCaselessEqual(url[3], 'p')
907         && (url[4] == ':' || (isASCIIAlphaCaselessEqual(url[4], 's') && length >= 6 && url[5] == ':'));
908 }
909
910 const URL& blankURL()
911 {
912     static NeverDestroyed<URL> staticBlankURL(ParsedURLString, "about:blank");
913     return staticBlankURL;
914 }
915
916 bool URL::isBlankURL() const
917 {
918     return protocolIs("about");
919 }
920
921 bool portAllowed(const URL& url)
922 {
923     std::optional<uint16_t> port = url.port();
924
925     // Since most URLs don't have a port, return early for the "no port" case.
926     if (!port)
927         return true;
928
929     // This blocked port list matches the port blocking that Mozilla implements.
930     // See http://www.mozilla.org/projects/netlib/PortBanning.html for more information.
931     static const uint16_t blockedPortList[] = {
932         1,    // tcpmux
933         7,    // echo
934         9,    // discard
935         11,   // systat
936         13,   // daytime
937         15,   // netstat
938         17,   // qotd
939         19,   // chargen
940         20,   // FTP-data
941         21,   // FTP-control
942         22,   // SSH
943         23,   // telnet
944         25,   // SMTP
945         37,   // time
946         42,   // name
947         43,   // nicname
948         53,   // domain
949         77,   // priv-rjs
950         79,   // finger
951         87,   // ttylink
952         95,   // supdup
953         101,  // hostriame
954         102,  // iso-tsap
955         103,  // gppitnp
956         104,  // acr-nema
957         109,  // POP2
958         110,  // POP3
959         111,  // sunrpc
960         113,  // auth
961         115,  // SFTP
962         117,  // uucp-path
963         119,  // nntp
964         123,  // NTP
965         135,  // loc-srv / epmap
966         139,  // netbios
967         143,  // IMAP2
968         179,  // BGP
969         389,  // LDAP
970         465,  // SMTP+SSL
971         512,  // print / exec
972         513,  // login
973         514,  // shell
974         515,  // printer
975         526,  // tempo
976         530,  // courier
977         531,  // Chat
978         532,  // netnews
979         540,  // UUCP
980         548,  // afpovertcp [Apple addition]
981         556,  // remotefs
982         563,  // NNTP+SSL
983         587,  // ESMTP
984         601,  // syslog-conn
985         636,  // LDAP+SSL
986         993,  // IMAP+SSL
987         995,  // POP3+SSL
988         2049, // NFS
989         3659, // apple-sasl / PasswordServer [Apple addition]
990         4045, // lockd
991         4190, // ManageSieve [Apple addition]
992         6000, // X11
993         6665, // Alternate IRC [Apple addition]
994         6666, // Alternate IRC [Apple addition]
995         6667, // Standard IRC [Apple addition]
996         6668, // Alternate IRC [Apple addition]
997         6669, // Alternate IRC [Apple addition]
998         6679, // Alternate IRC SSL [Apple addition]
999         6697, // IRC+SSL [Apple addition]
1000         invalidPortNumber, // Used to block all invalid port numbers
1001     };
1002
1003     // If the port is not in the blocked port list, allow it.
1004     ASSERT(std::is_sorted(std::begin(blockedPortList), std::end(blockedPortList)));
1005     if (!std::binary_search(std::begin(blockedPortList), std::end(blockedPortList), port.value()))
1006         return true;
1007
1008     // Allow ports 21 and 22 for FTP URLs, as Mozilla does.
1009     if ((port.value() == 21 || port.value() == 22) && url.protocolIs("ftp"))
1010         return true;
1011
1012     // Allow any port number in a file URL, since the port number is ignored.
1013     if (url.protocolIs("file"))
1014         return true;
1015
1016     return false;
1017 }
1018
1019 String mimeTypeFromDataURL(const String& url)
1020 {
1021     ASSERT(protocolIsInternal(url, "data"));
1022
1023     // FIXME: What's the right behavior when the URL has a comma first, but a semicolon later?
1024     // Currently this code will break at the semicolon in that case. Not sure that's correct.
1025     auto index = url.find(';', 5);
1026     if (index == notFound)
1027         index = url.find(',', 5);
1028     if (index == notFound) {
1029         // FIXME: There was an old comment here that made it sound like this should be returning text/plain.
1030         // But we have been returning empty string here for some time, so not changing its behavior at this time.
1031         return emptyString();
1032     }
1033     if (index == 5)
1034         return "text/plain"_s;
1035     ASSERT(index >= 5);
1036     return url.substring(5, index - 5).convertToASCIILowercase();
1037 }
1038
1039 String URL::stringCenterEllipsizedToLength(unsigned length) const
1040 {
1041     if (string().length() <= length)
1042         return string();
1043
1044     return string().left(length / 2 - 1) + "..." + string().right(length / 2 - 2);
1045 }
1046
1047 URL URL::fakeURLWithRelativePart(const String& relativePart)
1048 {
1049     return URL(URL(), "webkit-fake-url://" + createCanonicalUUIDString() + '/' + relativePart);
1050 }
1051
1052 URL URL::fileURLWithFileSystemPath(const String& filePath)
1053 {
1054     return URL(URL(), "file:///" + filePath);
1055 }
1056
1057 TextStream& operator<<(TextStream& ts, const URL& url)
1058 {
1059     ts << url.string();
1060     return ts;
1061 }
1062
1063 #if !PLATFORM(COCOA) && !USE(SOUP)
1064 bool URL::hostIsIPAddress(StringView host)
1065 {
1066     // Assume that any host that ends with a digit is trying to be an IP address.
1067     return !host.isEmpty() && isASCIIDigit(host[host.length() - 1]);
1068 }
1069 #endif
1070
1071 } // namespace WebCore