Adding upstream version 110.0.1.upstream/110.0.1upstream

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 645 insertions, 0 deletions

diff --git a/netwerk/base/nsURLParsers.cpp b/netwerk/base/nsURLParsers.cpp
new file mode 100644
index 0000000000..618222de42
--- /dev/null
+++ b/netwerk/base/nsURLParsers.cpp
@@ -0,0 +1,645 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <string.h>
+
+#include "mozilla/RangedPtr.h"
+#include "mozilla/TextUtils.h"
+
+#include "nsCRTGlue.h"
+#include "nsURLParsers.h"
+#include "nsURLHelper.h"
+#include "nsString.h"
+
+using namespace mozilla;
+
+//----------------------------------------------------------------------------
+
+static uint32_t CountConsecutiveSlashes(const char* str, int32_t len) {
+  RangedPtr<const char> p(str, len);
+  uint32_t count = 0;
+  while (len-- && *p++ == '/') ++count;
+  return count;
+}
+
+//----------------------------------------------------------------------------
+// nsBaseURLParser implementation
+//----------------------------------------------------------------------------
+
+NS_IMPL_ISUPPORTS(nsAuthURLParser, nsIURLParser)
+NS_IMPL_ISUPPORTS(nsNoAuthURLParser, nsIURLParser)
+
+#define SET_RESULT(component, pos, len)                \
+  PR_BEGIN_MACRO                                       \
+  if (component##Pos) *component##Pos = uint32_t(pos); \
+  if (component##Len) *component##Len = int32_t(len);  \
+  PR_END_MACRO
+
+#define OFFSET_RESULT(component, offset)           \
+  PR_BEGIN_MACRO                                   \
+  if (component##Pos) *component##Pos += (offset); \
+  PR_END_MACRO
+
+NS_IMETHODIMP
+nsBaseURLParser::ParseURL(const char* spec, int32_t specLen,
+                          uint32_t* schemePos, int32_t* schemeLen,
+                          uint32_t* authorityPos, int32_t* authorityLen,
+                          uint32_t* pathPos, int32_t* pathLen) {
+  if (NS_WARN_IF(!spec)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (specLen < 0) specLen = strlen(spec);
+
+  const char* stop = nullptr;
+  const char* colon = nullptr;
+  const char* slash = nullptr;
+  const char* p = spec;
+  uint32_t offset = 0;
+  int32_t len = specLen;
+
+  // skip leading whitespace
+  while (*p == ' ' || *p == '\n' || *p == '\r' || *p == '\t') {
+    spec++;
+    specLen--;
+    offset++;
+
+    p++;
+    len--;
+  }
+
+  for (; len && *p && !colon && !slash; ++p, --len) {
+    switch (*p) {
+      case ':':
+        if (!colon) colon = p;
+        break;
+      case '/':  // start of filepath
+      case '?':  // start of query
+      case '#':  // start of ref
+        if (!slash) slash = p;
+        break;
+      case '@':  // username@hostname
+      case '[':  // start of IPv6 address literal
+        if (!stop) stop = p;
+        break;
+    }
+  }
+  // disregard the first colon if it follows an '@' or a '['
+  if (colon && stop && colon > stop) colon = nullptr;
+
+  // if the spec only contained whitespace ...
+  if (specLen == 0) {
+    SET_RESULT(scheme, 0, -1);
+    SET_RESULT(authority, 0, 0);
+    SET_RESULT(path, 0, 0);
+    return NS_OK;
+  }
+
+  // ignore trailing whitespace and control characters
+  for (p = spec + specLen - 1; ((unsigned char)*p <= ' ') && (p != spec); --p) {
+    ;
+  }
+
+  specLen = p - spec + 1;
+
+  if (colon && (colon < slash || !slash)) {
+    //
+    // spec = <scheme>:/<the-rest>
+    //
+    // or
+    //
+    // spec = <scheme>:<authority>
+    // spec = <scheme>:<path-no-slashes>
+    //
+    if (!net_IsValidScheme(nsDependentCSubstring(spec, colon - spec)) ||
+        (*(colon + 1) == ':')) {
+      return NS_ERROR_MALFORMED_URI;
+    }
+    SET_RESULT(scheme, offset, colon - spec);
+    if (authorityLen || pathLen) {
+      uint32_t schemeLen = colon + 1 - spec;
+      offset += schemeLen;
+      ParseAfterScheme(colon + 1, specLen - schemeLen, authorityPos,
+                       authorityLen, pathPos, pathLen);
+      OFFSET_RESULT(authority, offset);
+      OFFSET_RESULT(path, offset);
+    }
+  } else {
+    //
+    // spec = <authority-no-port-or-password>/<path>
+    // spec = <path>
+    //
+    // or
+    //
+    // spec = <authority-no-port-or-password>/<path-with-colon>
+    // spec = <path-with-colon>
+    //
+    // or
+    //
+    // spec = <authority-no-port-or-password>
+    // spec = <path-no-slashes-or-colon>
+    //
+    SET_RESULT(scheme, 0, -1);
+    if (authorityLen || pathLen) {
+      ParseAfterScheme(spec, specLen, authorityPos, authorityLen, pathPos,
+                       pathLen);
+      OFFSET_RESULT(authority, offset);
+      OFFSET_RESULT(path, offset);
+    }
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseURLParser::ParseAuthority(const char* auth, int32_t authLen,
+                                uint32_t* usernamePos, int32_t* usernameLen,
+                                uint32_t* passwordPos, int32_t* passwordLen,
+                                uint32_t* hostnamePos, int32_t* hostnameLen,
+                                int32_t* port) {
+  if (NS_WARN_IF(!auth)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (authLen < 0) authLen = strlen(auth);
+
+  SET_RESULT(username, 0, -1);
+  SET_RESULT(password, 0, -1);
+  SET_RESULT(hostname, 0, authLen);
+  if (port) *port = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseURLParser::ParseUserInfo(const char* userinfo, int32_t userinfoLen,
+                               uint32_t* usernamePos, int32_t* usernameLen,
+                               uint32_t* passwordPos, int32_t* passwordLen) {
+  SET_RESULT(username, 0, -1);
+  SET_RESULT(password, 0, -1);
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseURLParser::ParseServerInfo(const char* serverinfo, int32_t serverinfoLen,
+                                 uint32_t* hostnamePos, int32_t* hostnameLen,
+                                 int32_t* port) {
+  SET_RESULT(hostname, 0, -1);
+  if (port) *port = -1;
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseURLParser::ParsePath(const char* path, int32_t pathLen,
+                           uint32_t* filepathPos, int32_t* filepathLen,
+                           uint32_t* queryPos, int32_t* queryLen,
+                           uint32_t* refPos, int32_t* refLen) {
+  if (NS_WARN_IF(!path)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (pathLen < 0) pathLen = strlen(path);
+
+  // path = [/]<segment1>/<segment2>/<...>/<segmentN>?<query>#<ref>
+
+  // XXX PL_strnpbrk would be nice, but it's buggy
+
+  // search for first occurrence of either ? or #
+  const char *query_beg = nullptr, *query_end = nullptr;
+  const char* ref_beg = nullptr;
+  const char* p = nullptr;
+  for (p = path; p < path + pathLen; ++p) {
+    // only match the query string if it precedes the reference fragment
+    if (!ref_beg && !query_beg && *p == '?') {
+      query_beg = p + 1;
+    } else if (*p == '#') {
+      ref_beg = p + 1;
+      if (query_beg) query_end = p;
+      break;
+    }
+  }
+
+  if (query_beg) {
+    if (query_end) {
+      SET_RESULT(query, query_beg - path, query_end - query_beg);
+    } else {
+      SET_RESULT(query, query_beg - path, pathLen - (query_beg - path));
+    }
+  } else {
+    SET_RESULT(query, 0, -1);
+  }
+
+  if (ref_beg) {
+    SET_RESULT(ref, ref_beg - path, pathLen - (ref_beg - path));
+  } else {
+    SET_RESULT(ref, 0, -1);
+  }
+
+  const char* end;
+  if (query_beg) {
+    end = query_beg - 1;
+  } else if (ref_beg) {
+    end = ref_beg - 1;
+  } else {
+    end = path + pathLen;
+  }
+
+  // an empty file path is no file path
+  if (end != path) {
+    SET_RESULT(filepath, 0, end - path);
+  } else {
+    SET_RESULT(filepath, 0, -1);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsBaseURLParser::ParseFilePath(const char* filepath, int32_t filepathLen,
+                               uint32_t* directoryPos, int32_t* directoryLen,
+                               uint32_t* basenamePos, int32_t* basenameLen,
+                               uint32_t* extensionPos, int32_t* extensionLen) {
+  if (NS_WARN_IF(!filepath)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (filepathLen < 0) filepathLen = strlen(filepath);
+
+  if (filepathLen == 0) {
+    SET_RESULT(directory, 0, -1);
+    SET_RESULT(basename, 0, 0);  // assume a zero length file basename
+    SET_RESULT(extension, 0, -1);
+    return NS_OK;
+  }
+
+  const char* p;
+  const char* end = filepath + filepathLen;
+
+  // search backwards for filename
+  for (p = end - 1; *p != '/' && p > filepath; --p) {
+    ;
+  }
+  if (*p == '/') {
+    // catch /.. and /.
+    if ((p + 1 < end && *(p + 1) == '.') &&
+        (p + 2 == end || (*(p + 2) == '.' && p + 3 == end))) {
+      p = end - 1;
+    }
+    // filepath = <directory><filename>.<extension>
+    SET_RESULT(directory, 0, p - filepath + 1);
+    ParseFileName(p + 1, end - (p + 1), basenamePos, basenameLen, extensionPos,
+                  extensionLen);
+    OFFSET_RESULT(basename, p + 1 - filepath);
+    OFFSET_RESULT(extension, p + 1 - filepath);
+  } else {
+    // filepath = <filename>.<extension>
+    SET_RESULT(directory, 0, -1);
+    ParseFileName(filepath, filepathLen, basenamePos, basenameLen, extensionPos,
+                  extensionLen);
+  }
+  return NS_OK;
+}
+
+nsresult nsBaseURLParser::ParseFileName(
+    const char* filename, int32_t filenameLen, uint32_t* basenamePos,
+    int32_t* basenameLen, uint32_t* extensionPos, int32_t* extensionLen) {
+  if (NS_WARN_IF(!filename)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (filenameLen < 0) filenameLen = strlen(filename);
+
+  // no extension if filename ends with a '.'
+  if (filename[filenameLen - 1] != '.') {
+    // ignore '.' at the beginning
+    for (const char* p = filename + filenameLen - 1; p > filename; --p) {
+      if (*p == '.') {
+        // filename = <basename.extension>
+        SET_RESULT(basename, 0, p - filename);
+        SET_RESULT(extension, p + 1 - filename,
+                   filenameLen - (p - filename + 1));
+        return NS_OK;
+      }
+    }
+  }
+  // filename = <basename>
+  SET_RESULT(basename, 0, filenameLen);
+  SET_RESULT(extension, 0, -1);
+  return NS_OK;
+}
+
+//----------------------------------------------------------------------------
+// nsNoAuthURLParser implementation
+//----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+nsNoAuthURLParser::ParseAuthority(const char* auth, int32_t authLen,
+                                  uint32_t* usernamePos, int32_t* usernameLen,
+                                  uint32_t* passwordPos, int32_t* passwordLen,
+                                  uint32_t* hostnamePos, int32_t* hostnameLen,
+                                  int32_t* port) {
+  MOZ_ASSERT_UNREACHABLE("Shouldn't parse auth in a NoAuthURL!");
+  return NS_ERROR_UNEXPECTED;
+}
+
+void nsNoAuthURLParser::ParseAfterScheme(const char* spec, int32_t specLen,
+                                         uint32_t* authPos, int32_t* authLen,
+                                         uint32_t* pathPos, int32_t* pathLen) {
+  MOZ_ASSERT(specLen >= 0, "unexpected");
+
+  // everything is the path
+  uint32_t pos = 0;
+  switch (CountConsecutiveSlashes(spec, specLen)) {
+    case 0:
+    case 1:
+      break;
+    case 2: {
+      const char* p = nullptr;
+      if (specLen > 2) {
+        // looks like there is an authority section
+
+        // if the authority looks like a drive number then we
+        // really want to treat it as part of the path
+        // [a-zA-Z][:|]{/\}
+        // i.e one of:   c:   c:\foo  c:/foo  c|  c|\foo  c|/foo
+        if ((specLen > 3) && (spec[3] == ':' || spec[3] == '|') &&
+            IsAsciiAlpha(spec[2]) &&
+            ((specLen == 4) || (spec[4] == '/') || (spec[4] == '\\'))) {
+          pos = 1;
+          break;
+        }
+        // Ignore apparent authority; path is everything after it
+        for (p = spec + 2; p < spec + specLen; ++p) {
+          if (*p == '/' || *p == '?' || *p == '#') break;
+        }
+      }
+      SET_RESULT(auth, 0, -1);
+      if (p && p != spec + specLen) {
+        SET_RESULT(path, p - spec, specLen - (p - spec));
+      } else {
+        SET_RESULT(path, 0, -1);
+      }
+      return;
+    }
+    default:
+      pos = 2;
+      break;
+  }
+  SET_RESULT(auth, pos, 0);
+  SET_RESULT(path, pos, specLen - pos);
+}
+
+#if defined(XP_WIN)
+NS_IMETHODIMP
+nsNoAuthURLParser::ParseFilePath(const char* filepath, int32_t filepathLen,
+                                 uint32_t* directoryPos, int32_t* directoryLen,
+                                 uint32_t* basenamePos, int32_t* basenameLen,
+                                 uint32_t* extensionPos,
+                                 int32_t* extensionLen) {
+  if (NS_WARN_IF(!filepath)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (filepathLen < 0) filepathLen = strlen(filepath);
+
+  // look for a filepath consisting of only a drive number, which may or
+  // may not have a leading slash.
+  if (filepathLen > 1 && filepathLen < 4) {
+    const char* end = filepath + filepathLen;
+    const char* p = filepath;
+    if (*p == '/') p++;
+    if ((end - p == 2) && (p[1] == ':' || p[1] == '|') && IsAsciiAlpha(*p)) {
+      // filepath = <drive-number>:
+      SET_RESULT(directory, 0, filepathLen);
+      SET_RESULT(basename, 0, -1);
+      SET_RESULT(extension, 0, -1);
+      return NS_OK;
+    }
+  }
+
+  // otherwise fallback on common implementation
+  return nsBaseURLParser::ParseFilePath(filepath, filepathLen, directoryPos,
+                                        directoryLen, basenamePos, basenameLen,
+                                        extensionPos, extensionLen);
+}
+#endif
+
+//----------------------------------------------------------------------------
+// nsAuthURLParser implementation
+//----------------------------------------------------------------------------
+
+NS_IMETHODIMP
+nsAuthURLParser::ParseAuthority(const char* auth, int32_t authLen,
+                                uint32_t* usernamePos, int32_t* usernameLen,
+                                uint32_t* passwordPos, int32_t* passwordLen,
+                                uint32_t* hostnamePos, int32_t* hostnameLen,
+                                int32_t* port) {
+  nsresult rv;
+
+  if (NS_WARN_IF(!auth)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (authLen < 0) authLen = strlen(auth);
+
+  if (authLen == 0) {
+    SET_RESULT(username, 0, -1);
+    SET_RESULT(password, 0, -1);
+    SET_RESULT(hostname, 0, 0);
+    if (port) *port = -1;
+    return NS_OK;
+  }
+
+  // search backwards for @
+  const char* p = auth + authLen - 1;
+  for (; (*p != '@') && (p > auth); --p) {
+  }
+  if (*p == '@') {
+    // auth = <user-info@server-info>
+    rv = ParseUserInfo(auth, p - auth, usernamePos, usernameLen, passwordPos,
+                       passwordLen);
+    if (NS_FAILED(rv)) return rv;
+    rv = ParseServerInfo(p + 1, authLen - (p - auth + 1), hostnamePos,
+                         hostnameLen, port);
+    if (NS_FAILED(rv)) return rv;
+    OFFSET_RESULT(hostname, p + 1 - auth);
+
+    // malformed if has a username or password
+    // but no host info, such as: http://u:p@/
+    if ((usernamePos || passwordPos) && (!hostnamePos || !*hostnameLen)) {
+      return NS_ERROR_MALFORMED_URI;
+    }
+  } else {
+    // auth = <server-info>
+    SET_RESULT(username, 0, -1);
+    SET_RESULT(password, 0, -1);
+    rv = ParseServerInfo(auth, authLen, hostnamePos, hostnameLen, port);
+    if (NS_FAILED(rv)) return rv;
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAuthURLParser::ParseUserInfo(const char* userinfo, int32_t userinfoLen,
+                               uint32_t* usernamePos, int32_t* usernameLen,
+                               uint32_t* passwordPos, int32_t* passwordLen) {
+  if (NS_WARN_IF(!userinfo)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (userinfoLen < 0) userinfoLen = strlen(userinfo);
+
+  if (userinfoLen == 0) {
+    SET_RESULT(username, 0, -1);
+    SET_RESULT(password, 0, -1);
+    return NS_OK;
+  }
+
+  const char* p = (const char*)memchr(userinfo, ':', userinfoLen);
+  if (p) {
+    // userinfo = <username:password>
+    SET_RESULT(username, 0, p - userinfo);
+    SET_RESULT(password, p - userinfo + 1, userinfoLen - (p - userinfo + 1));
+  } else {
+    // userinfo = <username>
+    SET_RESULT(username, 0, userinfoLen);
+    SET_RESULT(password, 0, -1);
+  }
+  return NS_OK;
+}
+
+NS_IMETHODIMP
+nsAuthURLParser::ParseServerInfo(const char* serverinfo, int32_t serverinfoLen,
+                                 uint32_t* hostnamePos, int32_t* hostnameLen,
+                                 int32_t* port) {
+  if (NS_WARN_IF(!serverinfo)) {
+    return NS_ERROR_INVALID_POINTER;
+  }
+
+  if (serverinfoLen < 0) serverinfoLen = strlen(serverinfo);
+
+  if (serverinfoLen == 0) {
+    SET_RESULT(hostname, 0, 0);
+    if (port) *port = -1;
+    return NS_OK;
+  }
+
+  // search backwards for a ':' but stop on ']' (IPv6 address literal
+  // delimiter).  check for illegal characters in the hostname.
+  const char* p = serverinfo + serverinfoLen - 1;
+  const char *colon = nullptr, *bracket = nullptr;
+  for (; p > serverinfo; --p) {
+    switch (*p) {
+      case ']':
+        bracket = p;
+        break;
+      case ':':
+        if (bracket == nullptr) colon = p;
+        break;
+      case ' ':
+        // hostname must not contain a space
+        return NS_ERROR_MALFORMED_URI;
+    }
+  }
+
+  if (colon) {
+    // serverinfo = <hostname:port>
+    SET_RESULT(hostname, 0, colon - serverinfo);
+    if (port) {
+      // XXX unfortunately ToInteger is not defined for substrings
+      nsAutoCString buf(colon + 1, serverinfoLen - (colon + 1 - serverinfo));
+      if (buf.Length() == 0) {
+        *port = -1;
+      } else {
+        const char* nondigit = NS_strspnp("0123456789", buf.get());
+        if (nondigit && *nondigit) return NS_ERROR_MALFORMED_URI;
+
+        nsresult err;
+        *port = buf.ToInteger(&err);
+        if (NS_FAILED(err) || *port < 0 ||
+            *port > std::numeric_limits<uint16_t>::max()) {
+          return NS_ERROR_MALFORMED_URI;
+        }
+      }
+    }
+  } else {
+    // serverinfo = <hostname>
+    SET_RESULT(hostname, 0, serverinfoLen);
+    if (port) *port = -1;
+  }
+
+  // In case of IPv6 address check its validity
+  if (*hostnameLen > 1 && *(serverinfo + *hostnamePos) == '[' &&
+      *(serverinfo + *hostnamePos + *hostnameLen - 1) == ']' &&
+      !net_IsValidIPv6Addr(
+          Substring(serverinfo + *hostnamePos + 1, *hostnameLen - 2))) {
+    return NS_ERROR_MALFORMED_URI;
+  }
+
+  return NS_OK;
+}
+
+void nsAuthURLParser::ParseAfterScheme(const char* spec, int32_t specLen,
+                                       uint32_t* authPos, int32_t* authLen,
+                                       uint32_t* pathPos, int32_t* pathLen) {
+  MOZ_ASSERT(specLen >= 0, "unexpected");
+
+  uint32_t nslash = CountConsecutiveSlashes(spec, specLen);
+
+  // search for the end of the authority section
+  const char* end = spec + specLen;
+  const char* p;
+  for (p = spec + nslash; p < end; ++p) {
+    if (*p == '/' || *p == '?' || *p == '#') break;
+  }
+  if (p < end) {
+    // spec = [/]<auth><path>
+    SET_RESULT(auth, nslash, p - (spec + nslash));
+    SET_RESULT(path, p - spec, specLen - (p - spec));
+  } else {
+    // spec = [/]<auth>
+    SET_RESULT(auth, nslash, specLen - nslash);
+    SET_RESULT(path, 0, -1);
+  }
+}
+
+//----------------------------------------------------------------------------
+// nsStdURLParser implementation
+//----------------------------------------------------------------------------
+
+void nsStdURLParser::ParseAfterScheme(const char* spec, int32_t specLen,
+                                      uint32_t* authPos, int32_t* authLen,
+                                      uint32_t* pathPos, int32_t* pathLen) {
+  MOZ_ASSERT(specLen >= 0, "unexpected");
+
+  uint32_t nslash = CountConsecutiveSlashes(spec, specLen);
+
+  // search for the end of the authority section
+  const char* end = spec + specLen;
+  const char* p;
+  for (p = spec + nslash; p < end; ++p) {
+    if (strchr("/?#;", *p)) break;
+  }
+  switch (nslash) {
+    case 0:
+    case 2:
+      if (p < end) {
+        // spec = (//)<auth><path>
+        SET_RESULT(auth, nslash, p - (spec + nslash));
+        SET_RESULT(path, p - spec, specLen - (p - spec));
+      } else {
+        // spec = (//)<auth>
+        SET_RESULT(auth, nslash, specLen - nslash);
+        SET_RESULT(path, 0, -1);
+      }
+      break;
+    case 1:
+      // spec = /<path>
+      SET_RESULT(auth, 0, -1);
+      SET_RESULT(path, 0, specLen);
+      break;
+    default:
+      // spec = ///[/]<path>
+      SET_RESULT(auth, 2, 0);
+      SET_RESULT(path, 2, specLen - 2);
+  }
+}