Source code

Revision control

Other Tools

/* -*- 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);
}
}