SecurityOrigin.cpp [plain text]
#include "config.h"
#include "SecurityOrigin.h"
#include "CString.h"
#include "FrameLoader.h"
#include "KURL.h"
#include "PlatformString.h"
#include <wtf/StdLibExtras.h>
namespace WebCore {
static bool isDefaultPortForProtocol(unsigned short port, const String& protocol)
{
if (protocol.isEmpty())
return false;
typedef HashMap<String, unsigned> DefaultPortsMap;
DEFINE_STATIC_LOCAL(DefaultPortsMap, defaultPorts, ());
if (defaultPorts.isEmpty()) {
defaultPorts.set("http", 80);
defaultPorts.set("https", 443);
defaultPorts.set("ftp", 21);
defaultPorts.set("ftps", 990);
}
return defaultPorts.get(protocol) == port;
}
SecurityOrigin::SecurityOrigin(const KURL& url)
: m_protocol(url.protocol().isNull() ? "" : url.protocol().lower())
, m_host(url.host().isNull() ? "" : url.host().lower())
, m_port(url.port())
, m_noAccess(false)
, m_domainWasSetInDOM(false)
{
if (m_protocol == "about" || m_protocol == "javascript")
m_protocol = "";
if (m_protocol == "data")
m_noAccess = true;
m_domain = m_host;
m_canLoadLocalResources = isLocal();
if (isDefaultPortForProtocol(m_port, m_protocol))
m_port = 0;
}
SecurityOrigin::SecurityOrigin(const SecurityOrigin* other)
: m_protocol(other->m_protocol.copy())
, m_host(other->m_host.copy())
, m_domain(other->m_domain.copy())
, m_port(other->m_port)
, m_noAccess(other->m_noAccess)
, m_domainWasSetInDOM(other->m_domainWasSetInDOM)
, m_canLoadLocalResources(other->m_canLoadLocalResources)
{
}
bool SecurityOrigin::isEmpty() const
{
return m_protocol.isEmpty();
}
PassRefPtr<SecurityOrigin> SecurityOrigin::create(const KURL& url)
{
if (!url.isValid())
return adoptRef(new SecurityOrigin(KURL()));
return adoptRef(new SecurityOrigin(url));
}
PassRefPtr<SecurityOrigin> SecurityOrigin::createEmpty()
{
return create(KURL());
}
PassRefPtr<SecurityOrigin> SecurityOrigin::copy()
{
return adoptRef(new SecurityOrigin(this));
}
void SecurityOrigin::setDomainFromDOM(const String& newDomain)
{
m_domainWasSetInDOM = true;
m_domain = newDomain.lower();
}
bool SecurityOrigin::canAccess(const SecurityOrigin* other) const
{
if (isLocal())
return true;
if (m_noAccess || other->m_noAccess)
return false;
if (m_protocol == other->m_protocol) {
if (!m_domainWasSetInDOM && !other->m_domainWasSetInDOM) {
if (m_host == other->m_host && m_port == other->m_port)
return true;
} else if (m_domainWasSetInDOM && other->m_domainWasSetInDOM) {
if (m_domain == other->m_domain)
return true;
}
}
return false;
}
bool SecurityOrigin::canRequest(const KURL& url) const
{
if (isLocal())
return true;
if (m_noAccess)
return false;
RefPtr<SecurityOrigin> targetOrigin = SecurityOrigin::create(url);
return isSameSchemeHostPort(targetOrigin.get());
}
void SecurityOrigin::grantLoadLocalResources()
{
ASSERT(FrameLoader::allowSubstituteDataAccessToLocal());
m_canLoadLocalResources = true;
}
bool SecurityOrigin::isLocal() const
{
return FrameLoader::shouldTreatSchemeAsLocal(m_protocol);
}
bool SecurityOrigin::isSecureTransitionTo(const KURL& url) const
{
if (isEmpty())
return true;
RefPtr<SecurityOrigin> other = SecurityOrigin::create(url);
return canAccess(other.get());
}
String SecurityOrigin::toString() const
{
if (isEmpty())
return "null";
if (m_noAccess)
return "null";
if (m_protocol == "file")
return String("file://");
Vector<UChar> result;
result.reserveInitialCapacity(m_protocol.length() + m_host.length() + 10);
append(result, m_protocol);
append(result, "://");
append(result, m_host);
if (m_port) {
append(result, ":");
append(result, String::number(m_port));
}
return String::adopt(result);
}
PassRefPtr<SecurityOrigin> SecurityOrigin::createFromString(const String& originString)
{
return SecurityOrigin::create(KURL(KURL(), originString));
}
static const char SeparatorCharacter = '_';
PassRefPtr<SecurityOrigin> SecurityOrigin::createFromDatabaseIdentifier(const String& databaseIdentifier)
{
int separator1 = databaseIdentifier.find(SeparatorCharacter);
if (separator1 == -1)
return create(KURL());
int separator2 = databaseIdentifier.find(SeparatorCharacter, separator1 + 1);
if (separator2 == -1)
return create(KURL());
if (databaseIdentifier.reverseFind(SeparatorCharacter) != separator2)
return create(KURL());
bool portOkay;
int port = databaseIdentifier.right(databaseIdentifier.length() - separator2 - 1).toInt(&portOkay);
if (!portOkay && separator2 + 1 == static_cast<int>(databaseIdentifier.length()))
return create(KURL());
if (port < 0 || port > 65535)
return create(KURL());
String protocol = databaseIdentifier.substring(0, separator1);
String host = databaseIdentifier.substring(separator1 + 1, separator2 - separator1 - 1);
return create(KURL(KURL(), protocol + "://" + host + ":" + String::number(port)));
}
String SecurityOrigin::databaseIdentifier() const
{
DEFINE_STATIC_LOCAL(String, separatorString, (&SeparatorCharacter, 1));
return m_protocol + separatorString + m_host + separatorString + String::number(m_port);
}
bool SecurityOrigin::equal(const SecurityOrigin* other) const
{
if (!isSameSchemeHostPort(other))
return false;
if (m_domainWasSetInDOM != other->m_domainWasSetInDOM)
return false;
if (m_domainWasSetInDOM && m_domain != other->m_domain)
return false;
return true;
}
bool SecurityOrigin::isSameSchemeHostPort(const SecurityOrigin* other) const
{
if (m_host != other->m_host)
return false;
if (m_protocol != other->m_protocol)
return false;
if (m_port != other->m_port)
return false;
return true;
}
}