RandomHuman
/
Mypal
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity
Mypal/dom/flyweb/FlyWebService.cpp

1311 lines
37 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
/* 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 "mozilla/dom/FlyWebService.h"
#include "mozilla/ClearOnShutdown.h"
#include "mozilla/StaticPtr.h"
#include "mozilla/ScopeExit.h"
#include "mozilla/dom/Promise.h"
#include "mozilla/dom/FlyWebPublishedServerIPC.h"
#include "mozilla/AddonPathService.h"
#include "nsISocketTransportService.h"
#include "mdns/libmdns/nsDNSServiceInfo.h"
#include "nsIUUIDGenerator.h"
#include "nsStandardURL.h"
#include "mozilla/Services.h"
#include "nsISupportsPrimitives.h"
#include "mozilla/dom/FlyWebDiscoveryManagerBinding.h"
#include "prnetdb.h"
#include "DNS.h"
#include "nsContentPermissionHelper.h"
#include "nsSocketTransportService2.h"
#include "nsSocketTransport2.h"
#include "nsHashPropertyBag.h"
#include "nsNetUtil.h"
#include "nsISimpleEnumerator.h"
#include "nsIProperty.h"
#include "nsICertOverrideService.h"
namespace mozilla {
namespace dom {
struct FlyWebPublishOptions;
static LazyLogModule gFlyWebServiceLog("FlyWebService");
#undef LOG_I
#define LOG_I(...) MOZ_LOG(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Debug, (__VA_ARGS__))
#undef LOG_E
#define LOG_E(...) MOZ_LOG(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Error, (__VA_ARGS__))
#undef LOG_TEST_I
#define LOG_TEST_I(...) MOZ_LOG_TEST(mozilla::dom::gFlyWebServiceLog, mozilla::LogLevel::Debug)
class FlyWebPublishServerPermissionCheck final
: public nsIContentPermissionRequest
, public nsIRunnable
{
public:
NS_DECL_ISUPPORTS
FlyWebPublishServerPermissionCheck(const nsCString& aServiceName, uint64_t aWindowID,
FlyWebPublishedServer* aServer)
: mServiceName(aServiceName)
, mWindowID(aWindowID)
, mServer(aServer)
{}
uint64_t WindowID() const
{
return mWindowID;
}
NS_IMETHOD Run() override
{
MOZ_ASSERT(NS_IsMainThread());
nsGlobalWindow* globalWindow = nsGlobalWindow::GetInnerWindowWithId(mWindowID);
if (!globalWindow) {
return Cancel();
}
mWindow = globalWindow->AsInner();
if (NS_WARN_IF(!mWindow)) {
return Cancel();
}
nsCOMPtr<nsIDocument> doc = mWindow->GetDoc();
if (NS_WARN_IF(!doc)) {
return Cancel();
}
mPrincipal = doc->NodePrincipal();
MOZ_ASSERT(mPrincipal);
mRequester = new nsContentPermissionRequester(mWindow);
return nsContentPermissionUtils::AskPermission(this, mWindow);
}
NS_IMETHOD Cancel() override
{
Resolve(false);
return NS_OK;
}
NS_IMETHOD Allow(JS::HandleValue aChoices) override
{
MOZ_ASSERT(aChoices.isUndefined());
Resolve(true);
return NS_OK;
}
NS_IMETHOD GetTypes(nsIArray** aTypes) override
{
nsTArray<nsString> emptyOptions;
return nsContentPermissionUtils::CreatePermissionArray(NS_LITERAL_CSTRING("flyweb-publish-server"),
NS_LITERAL_CSTRING("unused"), emptyOptions, aTypes);
}
NS_IMETHOD GetRequester(nsIContentPermissionRequester** aRequester) override
{
NS_ENSURE_ARG_POINTER(aRequester);
nsCOMPtr<nsIContentPermissionRequester> requester = mRequester;
requester.forget(aRequester);
return NS_OK;
}
NS_IMETHOD GetPrincipal(nsIPrincipal** aRequestingPrincipal) override
{
NS_IF_ADDREF(*aRequestingPrincipal = mPrincipal);
return NS_OK;
}
NS_IMETHOD GetWindow(mozIDOMWindow** aRequestingWindow) override
{
NS_IF_ADDREF(*aRequestingWindow = mWindow);
return NS_OK;
}
NS_IMETHOD GetElement(nsIDOMElement** aRequestingElement) override
{
*aRequestingElement = nullptr;
return NS_OK;
}
private:
void Resolve(bool aResolve)
{
mServer->PermissionGranted(aResolve);
}
virtual ~FlyWebPublishServerPermissionCheck() = default;
nsCString mServiceName;
uint64_t mWindowID;
RefPtr<FlyWebPublishedServer> mServer;
nsCOMPtr<nsPIDOMWindowInner> mWindow;
nsCOMPtr<nsIPrincipal> mPrincipal;
nsCOMPtr<nsIContentPermissionRequester> mRequester;
};
NS_IMPL_ISUPPORTS(FlyWebPublishServerPermissionCheck,
nsIContentPermissionRequest,
nsIRunnable)
class FlyWebMDNSService final
: public nsIDNSServiceDiscoveryListener
, public nsIDNSServiceResolveListener
, public nsIDNSRegistrationListener
, public nsITimerCallback
{
friend class FlyWebService;
private:
enum DiscoveryState {
DISCOVERY_IDLE,
DISCOVERY_STARTING,
DISCOVERY_RUNNING,
DISCOVERY_STOPPING
};
public:
NS_DECL_ISUPPORTS
NS_DECL_NSIDNSSERVICEDISCOVERYLISTENER
NS_DECL_NSIDNSSERVICERESOLVELISTENER
NS_DECL_NSIDNSREGISTRATIONLISTENER
NS_DECL_NSITIMERCALLBACK
explicit FlyWebMDNSService(FlyWebService* aService,
const nsACString& aServiceType);
private:
virtual ~FlyWebMDNSService() = default;
nsresult Init();
nsresult StartDiscovery();
nsresult StopDiscovery();
void ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices);
bool HasService(const nsAString& aServiceId);
nsresult PairWithService(const nsAString& aServiceId,
UniquePtr<FlyWebService::PairedInfo>& aInfo);
nsresult StartDiscoveryOf(FlyWebPublishedServerImpl* aServer);
void EnsureDiscoveryStarted();
void EnsureDiscoveryStopped();
// Cycle-breaking link to manager.
FlyWebService* mService;
nsCString mServiceType;
// Indicates the desired state of the system. If mDiscoveryActive is true,
// it indicates that backend discovery "should be happening", and discovery
// events should be forwarded to listeners.
// If false, the backend discovery "should be idle", and any discovery events
// that show up should not be forwarded to listeners.
bool mDiscoveryActive;
uint32_t mNumConsecutiveStartDiscoveryFailures;
// Represents the internal discovery state as it relates to nsDNSServiceDiscovery.
// When mDiscoveryActive is true, this state will periodically loop from
// (IDLE => STARTING => RUNNING => STOPPING => IDLE).
DiscoveryState mDiscoveryState;
nsCOMPtr<nsITimer> mDiscoveryStartTimer;
nsCOMPtr<nsITimer> mDiscoveryStopTimer;
nsCOMPtr<nsIDNSServiceDiscovery> mDNSServiceDiscovery;
nsCOMPtr<nsICancelable> mCancelDiscovery;
nsTHashtable<nsStringHashKey> mNewServiceSet;
struct DiscoveredInfo
{
explicit DiscoveredInfo(nsIDNSServiceInfo* aDNSServiceInfo);
FlyWebDiscoveredService mService;
nsCOMPtr<nsIDNSServiceInfo> mDNSServiceInfo;
};
nsClassHashtable<nsStringHashKey, DiscoveredInfo> mServiceMap;
};
void
LogDNSInfo(nsIDNSServiceInfo* aServiceInfo, const char* aFunc)
{
if (!LOG_TEST_I()) {
return;
}
nsCString tmp;
aServiceInfo->GetServiceName(tmp);
LOG_I("%s: serviceName=%s", aFunc, tmp.get());
aServiceInfo->GetHost(tmp);
LOG_I("%s: host=%s", aFunc, tmp.get());
aServiceInfo->GetAddress(tmp);
LOG_I("%s: address=%s", aFunc, tmp.get());
uint16_t port = -2;
aServiceInfo->GetPort(&port);
LOG_I("%s: port=%d", aFunc, (int)port);
nsCOMPtr<nsIPropertyBag2> attributes;
aServiceInfo->GetAttributes(getter_AddRefs(attributes));
if (!attributes) {
LOG_I("%s: no attributes", aFunc);
} else {
nsCOMPtr<nsISimpleEnumerator> enumerator;
attributes->GetEnumerator(getter_AddRefs(enumerator));
MOZ_ASSERT(enumerator);
LOG_I("%s: attributes start", aFunc);
bool hasMoreElements;
while (NS_SUCCEEDED(enumerator->HasMoreElements(&hasMoreElements)) &&
hasMoreElements) {
nsCOMPtr<nsISupports> element;
MOZ_ALWAYS_SUCCEEDS(enumerator->GetNext(getter_AddRefs(element)));
nsCOMPtr<nsIProperty> property = do_QueryInterface(element);
MOZ_ASSERT(property);
nsAutoString name;
nsCOMPtr<nsIVariant> value;
MOZ_ALWAYS_SUCCEEDS(property->GetName(name));
MOZ_ALWAYS_SUCCEEDS(property->GetValue(getter_AddRefs(value)));
nsAutoCString str;
nsresult rv = value->GetAsACString(str);
if (NS_SUCCEEDED(rv)) {
LOG_I("%s: attribute name=%s value=%s", aFunc,
NS_ConvertUTF16toUTF8(name).get(), str.get());
} else {
uint16_t type;
MOZ_ALWAYS_SUCCEEDS(value->GetDataType(&type));
LOG_I("%s: attribute *unstringifiable* name=%s type=%d", aFunc,
NS_ConvertUTF16toUTF8(name).get(), (int)type);
}
}
LOG_I("%s: attributes end", aFunc);
}
}
NS_IMPL_ISUPPORTS(FlyWebMDNSService,
nsIDNSServiceDiscoveryListener,
nsIDNSServiceResolveListener,
nsIDNSRegistrationListener,
nsITimerCallback)
FlyWebMDNSService::FlyWebMDNSService(
FlyWebService* aService,
const nsACString& aServiceType)
: mService(aService)
, mServiceType(aServiceType)
, mDiscoveryActive(false)
, mNumConsecutiveStartDiscoveryFailures(0)
, mDiscoveryState(DISCOVERY_IDLE)
{}
nsresult
FlyWebMDNSService::OnDiscoveryStarted(const nsACString& aServiceType)
{
MOZ_ASSERT(mDiscoveryState == DISCOVERY_STARTING);
mDiscoveryState = DISCOVERY_RUNNING;
// Reset consecutive start discovery failures.
mNumConsecutiveStartDiscoveryFailures = 0;
LOG_I("===========================================");
LOG_I("MDNSService::OnDiscoveryStarted(%s)", PromiseFlatCString(aServiceType).get());
LOG_I("===========================================");
// Clear the new service array.
mNewServiceSet.Clear();
// If service discovery is inactive, then stop network discovery immediately.
if (!mDiscoveryActive) {
// Set the stop timer to fire immediately.
Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStopTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
return NS_OK;
}
// Otherwise, set the stop timer to fire in 5 seconds.
Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStopTimer->InitWithCallback(this, 5 * 1000, nsITimer::TYPE_ONE_SHOT)));
return NS_OK;
}
nsresult
FlyWebMDNSService::OnDiscoveryStopped(const nsACString& aServiceType)
{
LOG_I("///////////////////////////////////////////");
LOG_I("MDNSService::OnDiscoveryStopped(%s)", PromiseFlatCString(aServiceType).get());
LOG_I("///////////////////////////////////////////");
MOZ_ASSERT(mDiscoveryState == DISCOVERY_STOPPING);
mDiscoveryState = DISCOVERY_IDLE;
// If service discovery is inactive, then discard all results and do not proceed.
if (!mDiscoveryActive) {
mServiceMap.Clear();
mNewServiceSet.Clear();
return NS_OK;
}
// Process the service map, add to the pair map.
for (auto iter = mServiceMap.Iter(); !iter.Done(); iter.Next()) {
DiscoveredInfo* service = iter.UserData();
if (!mNewServiceSet.Contains(service->mService.mServiceId)) {
iter.Remove();
}
}
// Notify FlyWebService of changed service list.
mService->NotifyDiscoveredServicesChanged();
// Start discovery again immediately.
Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStartTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
return NS_OK;
}
nsresult
FlyWebMDNSService::OnServiceFound(nsIDNSServiceInfo* aServiceInfo)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceFound");
// If discovery is not active, don't do anything with the result.
// If there is no discovery underway, ignore this.
if (!mDiscoveryActive || mDiscoveryState != DISCOVERY_RUNNING) {
return NS_OK;
}
// Discovery is underway - resolve the service.
nsresult rv = mDNSServiceDiscovery->ResolveService(aServiceInfo, this);
NS_ENSURE_SUCCESS(rv, rv);
return NS_OK;
}
nsresult
FlyWebMDNSService::OnServiceLost(nsIDNSServiceInfo* aServiceInfo)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceLost");
return NS_OK;
}
nsresult
FlyWebMDNSService::OnStartDiscoveryFailed(const nsACString& aServiceType, int32_t aErrorCode)
{
LOG_E("MDNSService::OnStartDiscoveryFailed(%s): %d", PromiseFlatCString(aServiceType).get(), (int) aErrorCode);
MOZ_ASSERT(mDiscoveryState == DISCOVERY_STARTING);
mDiscoveryState = DISCOVERY_IDLE;
mNumConsecutiveStartDiscoveryFailures++;
// If discovery is active, and the number of consecutive failures is < 3, try starting again.
if (mDiscoveryActive && mNumConsecutiveStartDiscoveryFailures < 3) {
Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStartTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
}
return NS_OK;
}
nsresult
FlyWebMDNSService::OnStopDiscoveryFailed(const nsACString& aServiceType, int32_t aErrorCode)
{
LOG_E("MDNSService::OnStopDiscoveryFailed(%s)", PromiseFlatCString(aServiceType).get());
MOZ_ASSERT(mDiscoveryState == DISCOVERY_STOPPING);
mDiscoveryState = DISCOVERY_IDLE;
// If discovery is active, start discovery again immediately.
if (mDiscoveryActive) {
Unused << NS_WARN_IF(NS_FAILED(mDiscoveryStartTimer->InitWithCallback(this, 0, nsITimer::TYPE_ONE_SHOT)));
}
return NS_OK;
}
static bool
IsAcceptableServiceAddress(const nsCString& addr)
{
PRNetAddr prNetAddr;
PRStatus status = PR_StringToNetAddr(addr.get(), &prNetAddr);
if (status == PR_FAILURE) {
return false;
}
// Only allow ipv4 addreses for now.
return prNetAddr.raw.family == PR_AF_INET;
}
nsresult
FlyWebMDNSService::OnServiceResolved(nsIDNSServiceInfo* aServiceInfo)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceResolved");
// If discovery is not active, don't do anything with the result.
// If there is no discovery underway, ignore this resolve.
if (!mDiscoveryActive || mDiscoveryState != DISCOVERY_RUNNING) {
return NS_OK;
}
nsresult rv;
nsCString address;
rv = aServiceInfo->GetAddress(address);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
if (!IsAcceptableServiceAddress(address)) {
return NS_OK;
}
// Create a new serviceInfo and stuff it in the new service array.
UniquePtr<DiscoveredInfo> svc(new DiscoveredInfo(aServiceInfo));
mNewServiceSet.PutEntry(svc->mService.mServiceId);
DiscoveredInfo* existingSvc =
mServiceMap.Get(svc->mService.mServiceId);
if (existingSvc) {
// Update the underlying DNS service info, but leave the old object in place.
existingSvc->mDNSServiceInfo = aServiceInfo;
} else {
DiscoveredInfo* info = svc.release();
mServiceMap.Put(info->mService.mServiceId, info);
}
// Notify FlyWebService of changed service list.
mService->NotifyDiscoveredServicesChanged();
return NS_OK;
}
FlyWebMDNSService::DiscoveredInfo::DiscoveredInfo(nsIDNSServiceInfo* aDNSServiceInfo)
: mDNSServiceInfo(aDNSServiceInfo)
{
nsCString tmp;
DebugOnly<nsresult> drv = aDNSServiceInfo->GetServiceName(tmp);
MOZ_ASSERT(NS_SUCCEEDED(drv));
CopyUTF8toUTF16(tmp, mService.mDisplayName);
mService.mTransport = NS_LITERAL_STRING("mdns");
drv = aDNSServiceInfo->GetServiceType(tmp);
MOZ_ASSERT(NS_SUCCEEDED(drv));
CopyUTF8toUTF16(tmp, mService.mServiceType);
nsCOMPtr<nsIPropertyBag2> attrs;
drv = aDNSServiceInfo->GetAttributes(getter_AddRefs(attrs));
MOZ_ASSERT(NS_SUCCEEDED(drv));
if (attrs) {
attrs->GetPropertyAsAString(NS_LITERAL_STRING("cert"), mService.mCert);
attrs->GetPropertyAsAString(NS_LITERAL_STRING("path"), mService.mPath);
}
// Construct a service id from the name, host, address, and port.
nsCString cHost;
drv = aDNSServiceInfo->GetHost(cHost);
MOZ_ASSERT(NS_SUCCEEDED(drv));
nsCString cAddress;
drv = aDNSServiceInfo->GetAddress(cAddress);
MOZ_ASSERT(NS_SUCCEEDED(drv));
uint16_t port;
drv = aDNSServiceInfo->GetPort(&port);
MOZ_ASSERT(NS_SUCCEEDED(drv));
nsAutoString portStr;
portStr.AppendInt(port, 10);
mService.mServiceId =
NS_ConvertUTF8toUTF16(cAddress) +
NS_LITERAL_STRING(":") +
portStr +
NS_LITERAL_STRING("|") +
mService.mServiceType +
NS_LITERAL_STRING("|") +
NS_ConvertUTF8toUTF16(cHost) +
NS_LITERAL_STRING("|") +
mService.mDisplayName;
}
nsresult
FlyWebMDNSService::OnResolveFailed(nsIDNSServiceInfo* aServiceInfo, int32_t aErrorCode)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnResolveFailed");
return NS_OK;
}
nsresult
FlyWebMDNSService::OnServiceRegistered(nsIDNSServiceInfo* aServiceInfo)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceRegistered");
nsCString cName;
if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
return NS_ERROR_FAILURE;
}
nsString name = NS_ConvertUTF8toUTF16(cName);
RefPtr<FlyWebPublishedServer> existingServer =
FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
if (!existingServer) {
return NS_ERROR_FAILURE;
}
existingServer->PublishedServerStarted(NS_OK);
return NS_OK;
}
nsresult
FlyWebMDNSService::OnServiceUnregistered(nsIDNSServiceInfo* aServiceInfo)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnServiceUnregistered");
nsCString cName;
if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
return NS_ERROR_FAILURE;
}
nsString name = NS_ConvertUTF8toUTF16(cName);
RefPtr<FlyWebPublishedServer> existingServer =
FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
if (!existingServer) {
return NS_ERROR_FAILURE;
}
LOG_I("OnServiceRegistered(MDNS): De-advertised server with name %s.", cName.get());
return NS_OK;
}
nsresult
FlyWebMDNSService::OnRegistrationFailed(nsIDNSServiceInfo* aServiceInfo, int32_t errorCode)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnRegistrationFailed");
nsCString cName;
if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
return NS_ERROR_FAILURE;
}
nsString name = NS_ConvertUTF8toUTF16(cName);
RefPtr<FlyWebPublishedServer> existingServer =
FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
if (!existingServer) {
return NS_ERROR_FAILURE;
}
LOG_I("OnServiceRegistered(MDNS): Registration of server with name %s failed.", cName.get());
// Remove the nsICancelable from the published server.
existingServer->PublishedServerStarted(NS_ERROR_FAILURE);
return NS_OK;
}
nsresult
FlyWebMDNSService::OnUnregistrationFailed(nsIDNSServiceInfo* aServiceInfo, int32_t errorCode)
{
LogDNSInfo(aServiceInfo, "FlyWebMDNSService::OnUnregistrationFailed");
nsCString cName;
if (NS_WARN_IF(NS_FAILED(aServiceInfo->GetServiceName(cName)))) {
return NS_ERROR_FAILURE;
}
nsString name = NS_ConvertUTF8toUTF16(cName);
RefPtr<FlyWebPublishedServer> existingServer =
FlyWebService::GetOrCreate()->FindPublishedServerByName(name);
if (!existingServer) {
return NS_ERROR_FAILURE;
}
LOG_I("OnServiceRegistered(MDNS): Un-Advertisement of server with name %s failed.", cName.get());
return NS_OK;
}
nsresult
FlyWebMDNSService::Notify(nsITimer* timer)
{
if (timer == mDiscoveryStopTimer.get()) {
LOG_I("MDNSService::Notify() got discovery stop timeout");
// Internet discovery stop timer has fired.
nsresult rv = StopDiscovery();
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
if (timer == mDiscoveryStartTimer.get()) {
LOG_I("MDNSService::Notify() got discovery start timeout");
// Internet discovery start timer has fired.
nsresult rv = StartDiscovery();
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
LOG_E("MDNSService::Notify got unknown timeout.");
return NS_OK;
}
nsresult
FlyWebMDNSService::Init()
{
MOZ_ASSERT(mDiscoveryState == DISCOVERY_IDLE);
mDiscoveryStartTimer = do_CreateInstance("@mozilla.org/timer;1");
if (!mDiscoveryStartTimer) {
return NS_ERROR_FAILURE;
}
mDiscoveryStopTimer = do_CreateInstance("@mozilla.org/timer;1");
if (!mDiscoveryStopTimer) {
return NS_ERROR_FAILURE;
}
nsresult rv;
mDNSServiceDiscovery = do_GetService(DNSSERVICEDISCOVERY_CONTRACT_ID, &rv);
if (NS_WARN_IF(NS_FAILED(rv))) {
return rv;
}
return NS_OK;
}
nsresult
FlyWebMDNSService::StartDiscovery()
{
nsresult rv;
// Always cancel the timer.
rv = mDiscoveryStartTimer->Cancel();
if (NS_WARN_IF(NS_FAILED(rv))) {
LOG_E("FlyWeb failed to cancel DNS service discovery start timer.");
}
// If discovery is not idle, don't start it.
if (mDiscoveryState != DISCOVERY_IDLE) {
return NS_OK;
}
LOG_I("FlyWeb starting dicovery.");
mDiscoveryState = DISCOVERY_STARTING;
// start the discovery.
rv = mDNSServiceDiscovery->StartDiscovery(mServiceType, this,
getter_AddRefs(mCancelDiscovery));
if (NS_WARN_IF(NS_FAILED(rv))) {
LOG_E("FlyWeb failed to start DNS service discovery.");
return rv;
}
return NS_OK;
}
nsresult
FlyWebMDNSService::StopDiscovery()
{
nsresult rv;
// Always cancel the timer.
rv = mDiscoveryStopTimer->Cancel();
if (NS_WARN_IF(NS_FAILED(rv))) {
LOG_E("FlyWeb failed to cancel DNS service discovery stop timer.");
}
// If discovery is not running, do nothing.
if (mDiscoveryState != DISCOVERY_RUNNING) {
return NS_OK;
}
LOG_I("FlyWeb stopping dicovery.");
// Mark service discovery as stopping.
mDiscoveryState = DISCOVERY_STOPPING;
if (mCancelDiscovery) {
LOG_I("MDNSService::StopDiscovery() - mCancelDiscovery exists!");
nsCOMPtr<nsICancelable> cancelDiscovery = mCancelDiscovery.forget();
rv = cancelDiscovery->Cancel(NS_ERROR_ABORT);
if (NS_WARN_IF(NS_FAILED(rv))) {
LOG_E("FlyWeb failed to cancel DNS stop service discovery.");
}
} else {
LOG_I("MDNSService::StopDiscovery() - mCancelDiscovery does not exist!");
mDiscoveryState = DISCOVERY_IDLE;
}
return NS_OK;
}
void
FlyWebMDNSService::ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices)
{
for (auto iter = mServiceMap.Iter(); !iter.Done(); iter.Next()) {
aServices.AppendElement(iter.UserData()->mService);
}
}
bool
FlyWebMDNSService::HasService(const nsAString& aServiceId)
{
return mServiceMap.Contains(aServiceId);
}
nsresult
FlyWebMDNSService::PairWithService(const nsAString& aServiceId,
UniquePtr<FlyWebService::PairedInfo>& aInfo)
{
MOZ_ASSERT(HasService(aServiceId));
nsresult rv;
nsCOMPtr<nsIUUIDGenerator> uuidgen =
do_GetService("@mozilla.org/uuid-generator;1", &rv);
NS_ENSURE_SUCCESS(rv, rv);
nsID id;
rv = uuidgen->GenerateUUIDInPlace(&id);
NS_ENSURE_SUCCESS(rv, rv);
aInfo.reset(new FlyWebService::PairedInfo());
char uuidChars[NSID_LENGTH];
id.ToProvidedString(uuidChars);
CopyUTF8toUTF16(Substring(uuidChars + 1, uuidChars + NSID_LENGTH - 2),
aInfo->mService.mHostname);
DiscoveredInfo* discInfo = mServiceMap.Get(aServiceId);
nsAutoString url;
if (discInfo->mService.mCert.IsEmpty()) {
url.AssignLiteral("http://");
} else {
url.AssignLiteral("https://");
}
url.Append(aInfo->mService.mHostname + NS_LITERAL_STRING("/"));
nsCOMPtr<nsIURI> uiURL;
NS_NewURI(getter_AddRefs(uiURL), url);
MOZ_ASSERT(uiURL);
if (!discInfo->mService.mPath.IsEmpty()) {
nsCOMPtr<nsIURI> tmp = uiURL.forget();
NS_NewURI(getter_AddRefs(uiURL), discInfo->mService.mPath, nullptr, tmp);
}
if (uiURL) {
nsAutoCString spec;
uiURL->GetSpec(spec);
CopyUTF8toUTF16(spec, aInfo->mService.mUiUrl);
}
aInfo->mService.mDiscoveredService = discInfo->mService;
aInfo->mDNSServiceInfo = discInfo->mDNSServiceInfo;
return NS_OK;
}
nsresult
FlyWebMDNSService::StartDiscoveryOf(FlyWebPublishedServerImpl* aServer)
{
RefPtr<FlyWebPublishedServer> existingServer =
FlyWebService::GetOrCreate()->FindPublishedServerByName(aServer->Name());
MOZ_ASSERT(existingServer);
// Advertise the service via mdns.
RefPtr<net::nsDNSServiceInfo> serviceInfo(new net::nsDNSServiceInfo());
serviceInfo->SetPort(aServer->Port());
serviceInfo->SetServiceType(mServiceType);
nsCString certKey;
aServer->GetCertKey(certKey);
nsString uiURL;
aServer->GetUiUrl(uiURL);
if (!uiURL.IsEmpty() || !certKey.IsEmpty()) {
RefPtr<nsHashPropertyBag> attrs = new nsHashPropertyBag();
if (!uiURL.IsEmpty()) {
attrs->SetPropertyAsAString(NS_LITERAL_STRING("path"), uiURL);
}
if (!certKey.IsEmpty()) {
attrs->SetPropertyAsACString(NS_LITERAL_STRING("cert"), certKey);
}
serviceInfo->SetAttributes(attrs);
}
nsCString cstrName = NS_ConvertUTF16toUTF8(aServer->Name());
LOG_I("MDNSService::StartDiscoveryOf() advertising service %s", cstrName.get());
serviceInfo->SetServiceName(cstrName);
LogDNSInfo(serviceInfo, "FlyWebMDNSService::StartDiscoveryOf");
// Advertise the service.
nsCOMPtr<nsICancelable> cancelRegister;
nsresult rv = mDNSServiceDiscovery->
RegisterService(serviceInfo, this, getter_AddRefs(cancelRegister));
NS_ENSURE_SUCCESS(rv, rv);
// All done.
aServer->SetCancelRegister(cancelRegister);
return NS_OK;
}
void
FlyWebMDNSService::EnsureDiscoveryStarted()
{
mDiscoveryActive = true;
// If state is idle, start discovery immediately.
if (mDiscoveryState == DISCOVERY_IDLE) {
StartDiscovery();
}
}
void
FlyWebMDNSService::EnsureDiscoveryStopped()
{
// All we need to do is set the flag to false.
// If current state is IDLE, it's already the correct state.
// Otherwise, the handlers for the internal state
// transitions will check this flag and drive the state
// towards IDLE.
mDiscoveryActive = false;
}
static StaticRefPtr<FlyWebService> gFlyWebService;
NS_IMPL_ISUPPORTS(FlyWebService, nsIObserver)
FlyWebService::FlyWebService()
: mMonitor("FlyWebService::mMonitor")
{
MOZ_ASSERT(NS_IsMainThread());
nsCOMPtr<nsIObserverService> obs = mozilla::services::GetObserverService();
if (obs) {
obs->AddObserver(this, "inner-window-destroyed", false);
}
}
FlyWebService::~FlyWebService()
{
}
FlyWebService*
FlyWebService::GetExisting()
{
return gFlyWebService;
}
FlyWebService*
FlyWebService::GetOrCreate()
{
if (!gFlyWebService) {
gFlyWebService = new FlyWebService();
ClearOnShutdown(&gFlyWebService);
ErrorResult rv = gFlyWebService->Init();
if (rv.Failed()) {
gFlyWebService = nullptr;
return nullptr;
}
}
return gFlyWebService;
}
ErrorResult
FlyWebService::Init()
{
// Most functions of FlyWebService should not be started in the child.
// Instead FlyWebService in the child is mainly responsible for tracking
// publishedServer lifetimes. Other functions are handled by the
// FlyWebService running in the parent.
if (XRE_GetProcessType() == GeckoProcessType_Content) {
return ErrorResult(NS_OK);
}
MOZ_ASSERT(NS_IsMainThread());
if (!mMDNSHttpService) {
mMDNSHttpService = new FlyWebMDNSService(this, NS_LITERAL_CSTRING("_http._tcp."));
ErrorResult rv;
rv = mMDNSHttpService->Init();
if (rv.Failed()) {
LOG_E("FlyWebService failed to initialize MDNS _http._tcp.");
mMDNSHttpService = nullptr;
rv.SuppressException();
}
}
if (!mMDNSFlywebService) {
mMDNSFlywebService = new FlyWebMDNSService(this, NS_LITERAL_CSTRING("_flyweb._tcp."));
ErrorResult rv;
rv = mMDNSFlywebService->Init();
if (rv.Failed()) {
LOG_E("FlyWebService failed to initialize MDNS _flyweb._tcp.");
mMDNSFlywebService = nullptr;
rv.SuppressException();
}
}
return ErrorResult(NS_OK);
}
static already_AddRefed<FlyWebPublishPromise>
MakeRejectionPromise(const char* name)
{
MozPromiseHolder<FlyWebPublishPromise> holder;
RefPtr<FlyWebPublishPromise> promise = holder.Ensure(name);
holder.Reject(NS_ERROR_FAILURE, name);
return promise.forget();
}
static bool
CheckForFlyWebAddon(const nsACString& uriString)
{
// Before proceeding, ensure that the FlyWeb system addon exists.
nsresult rv;
nsCOMPtr<nsIURI> uri;
rv = NS_NewURI(getter_AddRefs(uri), uriString);
if (NS_FAILED(rv)) {
return false;
}
JSAddonId *addonId = MapURIToAddonID(uri);
if (!addonId) {
return false;
}
JSFlatString* flat = JS_ASSERT_STRING_IS_FLAT(JS::StringOfAddonId(addonId));
nsAutoString addonIdString;
AssignJSFlatString(addonIdString, flat);
if (!addonIdString.EqualsLiteral("flyweb@mozilla.org")) {
nsCString addonIdCString = NS_ConvertUTF16toUTF8(addonIdString);
return false;
}
return true;
}
already_AddRefed<FlyWebPublishPromise>
FlyWebService::PublishServer(const nsAString& aName,
const FlyWebPublishOptions& aOptions,
nsPIDOMWindowInner* aWindow)
{
// Scan uiUrl for illegal characters
RefPtr<FlyWebPublishedServer> existingServer =
FlyWebService::GetOrCreate()->FindPublishedServerByName(aName);
if (existingServer) {
LOG_I("PublishServer: Trying to publish server with already-existing name %s.",
NS_ConvertUTF16toUTF8(aName).get());
return MakeRejectionPromise(__func__);
}
RefPtr<FlyWebPublishedServer> server;
if (XRE_GetProcessType() == GeckoProcessType_Content) {
server = new FlyWebPublishedServerChild(aWindow, aName, aOptions);
} else {
server = new FlyWebPublishedServerImpl(aWindow, aName, aOptions);
// Before proceeding, ensure that the FlyWeb system addon exists.
if (!CheckForFlyWebAddon(NS_LITERAL_CSTRING("chrome://flyweb/skin/icon-64.png")) &&
!CheckForFlyWebAddon(NS_LITERAL_CSTRING("chrome://flyweb/content/icon-64.png")))
{
LOG_E("PublishServer: Failed to find FlyWeb system addon.");
return MakeRejectionPromise(__func__);
}
}
if (aWindow) {
nsresult rv;
MOZ_ASSERT(NS_IsMainThread());
rv = NS_DispatchToCurrentThread(
MakeAndAddRef<FlyWebPublishServerPermissionCheck>(
NS_ConvertUTF16toUTF8(aName), aWindow->WindowID(), server));
if (NS_WARN_IF(NS_FAILED(rv))) {
LOG_E("PublishServer: Failed to dispatch permission check runnable for %s",
NS_ConvertUTF16toUTF8(aName).get());
return MakeRejectionPromise(__func__);
}
} else {
// If aWindow is null, we're definitely in the e10s parent process.
// In this case, we know that permission has already been granted
// by the user because of content-process prompt.
MOZ_ASSERT(XRE_GetProcessType() == GeckoProcessType_Default);
server->PermissionGranted(true);
}
mServers.AppendElement(server);
return server->GetPublishPromise();
}
already_AddRefed<FlyWebPublishedServer>
FlyWebService::FindPublishedServerByName(
const nsAString& aName)
{
MOZ_ASSERT(NS_IsMainThread());
for (FlyWebPublishedServer* publishedServer : mServers) {
if (publishedServer->Name().Equals(aName)) {
RefPtr<FlyWebPublishedServer> server = publishedServer;
return server.forget();
}
}
return nullptr;
}
void
FlyWebService::RegisterDiscoveryManager(FlyWebDiscoveryManager* aDiscoveryManager)
{
MOZ_ASSERT(NS_IsMainThread());
mDiscoveryManagerTable.PutEntry(aDiscoveryManager);
if (mMDNSHttpService) {
mMDNSHttpService->EnsureDiscoveryStarted();
}
if (mMDNSFlywebService) {
mMDNSFlywebService->EnsureDiscoveryStarted();
}
}
void
FlyWebService::UnregisterDiscoveryManager(FlyWebDiscoveryManager* aDiscoveryManager)
{
MOZ_ASSERT(NS_IsMainThread());
mDiscoveryManagerTable.RemoveEntry(aDiscoveryManager);
if (mDiscoveryManagerTable.IsEmpty()) {
if (mMDNSHttpService) {
mMDNSHttpService->EnsureDiscoveryStopped();
}
if (mMDNSFlywebService) {
mMDNSFlywebService->EnsureDiscoveryStopped();
}
}
}
NS_IMETHODIMP
FlyWebService::Observe(nsISupports* aSubject, const char* aTopic,
const char16_t* aData)
{
MOZ_ASSERT(NS_IsMainThread());
if (strcmp(aTopic, "inner-window-destroyed")) {
return NS_OK;
}
nsCOMPtr<nsISupportsPRUint64> wrapper = do_QueryInterface(aSubject);
NS_ENSURE_TRUE(wrapper, NS_ERROR_FAILURE);
uint64_t innerID;
nsresult rv = wrapper->GetData(&innerID);
NS_ENSURE_SUCCESS(rv, rv);
for (FlyWebPublishedServer* server : mServers) {
if (server->OwnerWindowID() == innerID) {
server->Close();
}
}
return NS_OK;
}
void
FlyWebService::UnregisterServer(FlyWebPublishedServer* aServer)
{
MOZ_ASSERT(NS_IsMainThread());
DebugOnly<bool> removed = mServers.RemoveElement(aServer);
MOZ_ASSERT(removed);
}
bool
FlyWebService::HasConnectionOrServer(uint64_t aWindowID)
{
MOZ_ASSERT(NS_IsMainThread());
for (FlyWebPublishedServer* server : mServers) {
nsPIDOMWindowInner* win = server->GetOwner();
if (win && win->WindowID() == aWindowID) {
return true;
}
}
return false;
}
void
FlyWebService::NotifyDiscoveredServicesChanged()
{
// Process the service map, add to the pair map.
for (auto iter = mDiscoveryManagerTable.Iter(); !iter.Done(); iter.Next()) {
iter.Get()->GetKey()->NotifyDiscoveredServicesChanged();
}
}
void
FlyWebService::ListDiscoveredServices(nsTArray<FlyWebDiscoveredService>& aServices)
{
MOZ_ASSERT(NS_IsMainThread());
if (mMDNSHttpService) {
mMDNSHttpService->ListDiscoveredServices(aServices);
}
if (mMDNSFlywebService) {
mMDNSFlywebService->ListDiscoveredServices(aServices);
}
}
void
FlyWebService::PairWithService(const nsAString& aServiceId,
FlyWebPairingCallback& aCallback)
{
MOZ_ASSERT(NS_IsMainThread());
// See if we have already paired with this service. If so, re-use the
// FlyWebPairedService for that.
{
ReentrantMonitorAutoEnter pairedMapLock(mMonitor);
for (auto iter = mPairedServiceTable.Iter(); !iter.Done(); iter.Next()) {
PairedInfo* pairInfo = iter.UserData();
if (pairInfo->mService.mDiscoveredService.mServiceId.Equals(aServiceId)) {
ErrorResult er;
ReentrantMonitorAutoExit pairedMapRelease(mMonitor);
aCallback.PairingSucceeded(pairInfo->mService, er);
ENSURE_SUCCESS_VOID(er);
return;
}
}
}
UniquePtr<PairedInfo> pairInfo;
nsresult rv = NS_OK;
bool notFound = false;
if (mMDNSHttpService && mMDNSHttpService->HasService(aServiceId)) {
rv = mMDNSHttpService->PairWithService(aServiceId, pairInfo);
} else if (mMDNSFlywebService && mMDNSFlywebService->HasService(aServiceId)) {
rv = mMDNSFlywebService->PairWithService(aServiceId, pairInfo);
} else {
notFound = true;
}
if (NS_FAILED(rv)) {
ErrorResult result;
result.Throw(rv);
const nsAString& reason = NS_LITERAL_STRING("Error pairing.");
aCallback.PairingFailed(reason, result);
ENSURE_SUCCESS_VOID(result);
return;
}
if (!pairInfo) {
ErrorResult res;
const nsAString& reason = notFound ?
NS_LITERAL_STRING("No such service.") :
NS_LITERAL_STRING("Error pairing.");
aCallback.PairingFailed(reason, res);
ENSURE_SUCCESS_VOID(res);
return;
}
// Add fingerprint to certificate override database.
if (!pairInfo->mService.mDiscoveredService.mCert.IsEmpty()) {
nsCOMPtr<nsICertOverrideService> override =
do_GetService("@mozilla.org/security/certoverride;1");
if (!override ||
NS_FAILED(override->RememberTemporaryValidityOverrideUsingFingerprint(
NS_ConvertUTF16toUTF8(pairInfo->mService.mHostname),
-1,
NS_ConvertUTF16toUTF8(pairInfo->mService.mDiscoveredService.mCert),
nsICertOverrideService::ERROR_UNTRUSTED |
nsICertOverrideService::ERROR_MISMATCH))) {
ErrorResult res;
aCallback.PairingFailed(NS_LITERAL_STRING("Error adding certificate override."), res);
ENSURE_SUCCESS_VOID(res);
return;
}
}
// Grab a weak reference to the PairedInfo so that we can
// use it even after ownership has been transferred to mPairedServiceTable
PairedInfo* pairInfoWeak = pairInfo.release();
{
ReentrantMonitorAutoEnter pairedMapLock(mMonitor);
mPairedServiceTable.Put(
NS_ConvertUTF16toUTF8(pairInfoWeak->mService.mHostname), pairInfoWeak);
}
ErrorResult er;
aCallback.PairingSucceeded(pairInfoWeak->mService, er);
ENSURE_SUCCESS_VOID(er);
}
nsresult
FlyWebService::CreateTransportForHost(const char **types,
uint32_t typeCount,
const nsACString &host,
int32_t port,
const nsACString &hostRoute,
int32_t portRoute,
nsIProxyInfo *proxyInfo,
nsISocketTransport **result)
{
// This might be called on background threads
*result = nullptr;
nsCString ipAddrString;
uint16_t discPort;
{
ReentrantMonitorAutoEnter pairedMapLock(mMonitor);
PairedInfo* info = mPairedServiceTable.Get(host);
if (!info) {
return NS_OK;
}
// Get the ip address of the underlying service.
info->mDNSServiceInfo->GetAddress(ipAddrString);
info->mDNSServiceInfo->GetPort(&discPort);
}
// Parse it into an NetAddr.
PRNetAddr prNetAddr;
PRStatus status = PR_StringToNetAddr(ipAddrString.get(), &prNetAddr);
NS_ENSURE_FALSE(status == PR_FAILURE, NS_ERROR_FAILURE);
// Convert PRNetAddr to NetAddr.
mozilla::net::NetAddr netAddr;
PRNetAddrToNetAddr(&prNetAddr, &netAddr);
netAddr.inet.port = htons(discPort);
RefPtr<mozilla::net::nsSocketTransport> trans = new mozilla::net::nsSocketTransport();
nsresult rv = trans->InitPreResolved(
types, typeCount, host, port, hostRoute, portRoute, proxyInfo, &netAddr);
NS_ENSURE_SUCCESS(rv, rv);
trans.forget(result);
return NS_OK;
}
void
FlyWebService::StartDiscoveryOf(FlyWebPublishedServerImpl* aServer)
{
MOZ_ASSERT(NS_IsMainThread());
nsresult rv = mMDNSFlywebService ?
mMDNSFlywebService->StartDiscoveryOf(aServer) :
NS_ERROR_FAILURE;
if (NS_FAILED(rv)) {
aServer->PublishedServerStarted(rv);
}
}
} // namespace dom
} // namespace mozilla
Reference in New Issue View Git Blame Copy Permalink