mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/netwerk/base/Dashboard.cpp

925 строки
24 KiB
C++
Исходник Ответственный История

/* 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/NetDashboardBinding.h"
#include "mozilla/dom/ToJSValue.h"
#include "mozilla/ErrorNames.h"
#include "mozilla/net/Dashboard.h"
#include "mozilla/net/HttpInfo.h"
#include "nsHttp.h"
#include "nsICancelable.h"
#include "nsIDNSService.h"
#include "nsIDNSRecord.h"
#include "nsIInputStream.h"
#include "nsISocketTransport.h"
#include "nsIThread.h"
#include "nsProxyRelease.h"
#include "nsSocketTransportService2.h"
#include "nsThreadUtils.h"
#include "nsURLHelper.h"
#include "mozilla/Logging.h"
using mozilla::AutoSafeJSContext;
using mozilla::dom::Sequence;
using mozilla::dom::ToJSValue;
namespace mozilla {
namespace net {
class SocketData
: public nsISupports
{
public:
NS_DECL_THREADSAFE_ISUPPORTS
SocketData()
{
mTotalSent = 0;
mTotalRecv = 0;
mThread = nullptr;
}
uint64_t mTotalSent;
uint64_t mTotalRecv;
nsTArray<SocketInfo> mData;
nsMainThreadPtrHandle<NetDashboardCallback> mCallback;
nsIThread *mThread;
private:
virtual ~SocketData()
{
}
};
static void GetErrorString(nsresult rv, nsAString& errorString);
NS_IMPL_ISUPPORTS0(SocketData)
class HttpData
: public nsISupports
{
virtual ~HttpData()
{
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
HttpData()
{
mThread = nullptr;
}
nsTArray<HttpRetParams> mData;
nsMainThreadPtrHandle<NetDashboardCallback> mCallback;
nsIThread *mThread;
};
NS_IMPL_ISUPPORTS0(HttpData)
class WebSocketRequest
: public nsISupports
{
virtual ~WebSocketRequest()
{
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
WebSocketRequest()
{
mThread = nullptr;
}
nsMainThreadPtrHandle<NetDashboardCallback> mCallback;
nsIThread *mThread;
};
NS_IMPL_ISUPPORTS0(WebSocketRequest)
class DnsData
: public nsISupports
{
virtual ~DnsData()
{
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
DnsData()
{
mThread = nullptr;
}
nsTArray<DNSCacheEntries> mData;
nsMainThreadPtrHandle<NetDashboardCallback> mCallback;
nsIThread *mThread;
};
NS_IMPL_ISUPPORTS0(DnsData)
class ConnectionData
: public nsITransportEventSink
, public nsITimerCallback
{
virtual ~ConnectionData()
{
if (mTimer) {
mTimer->Cancel();
}
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSITRANSPORTEVENTSINK
NS_DECL_NSITIMERCALLBACK
void StartTimer(uint32_t aTimeout);
void StopTimer();
explicit ConnectionData(Dashboard *target)
{
mThread = nullptr;
mDashboard = target;
}
nsCOMPtr<nsISocketTransport> mSocket;
nsCOMPtr<nsIInputStream> mStreamIn;
nsCOMPtr<nsITimer> mTimer;
nsMainThreadPtrHandle<NetDashboardCallback> mCallback;
nsIThread *mThread;
Dashboard *mDashboard;
nsCString mHost;
uint32_t mPort;
const char *mProtocol;
uint32_t mTimeout;
nsString mStatus;
};
NS_IMPL_ISUPPORTS(ConnectionData, nsITransportEventSink, nsITimerCallback)
NS_IMETHODIMP
ConnectionData::OnTransportStatus(nsITransport *aTransport, nsresult aStatus,
int64_t aProgress, int64_t aProgressMax)
{
if (aStatus == NS_NET_STATUS_CONNECTED_TO) {
StopTimer();
}
GetErrorString(aStatus, mStatus);
mThread->Dispatch(NewRunnableMethod<RefPtr<ConnectionData>>
(mDashboard, &Dashboard::GetConnectionStatus, this),
NS_DISPATCH_NORMAL);
return NS_OK;
}
NS_IMETHODIMP
ConnectionData::Notify(nsITimer *aTimer)
{
MOZ_ASSERT(aTimer == mTimer);
if (mSocket) {
mSocket->Close(NS_ERROR_ABORT);
mSocket = nullptr;
mStreamIn = nullptr;
}
mTimer = nullptr;
mStatus.AssignLiteral(u"NS_ERROR_NET_TIMEOUT");
mThread->Dispatch(NewRunnableMethod<RefPtr<ConnectionData>>
(mDashboard, &Dashboard::GetConnectionStatus, this),
NS_DISPATCH_NORMAL);
return NS_OK;
}
void
ConnectionData::StartTimer(uint32_t aTimeout)
{
if (!mTimer) {
mTimer = do_CreateInstance("@mozilla.org/timer;1");
}
mTimer->InitWithCallback(this, aTimeout * 1000,
nsITimer::TYPE_ONE_SHOT);
}
void
ConnectionData::StopTimer()
{
if (mTimer) {
mTimer->Cancel();
mTimer = nullptr;
}
}
class LookupHelper;
class LookupArgument
: public nsISupports
{
virtual ~LookupArgument()
{
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
LookupArgument(nsIDNSRecord *aRecord, LookupHelper *aHelper)
{
mRecord = aRecord;
mHelper = aHelper;
}
nsCOMPtr<nsIDNSRecord> mRecord;
RefPtr<LookupHelper> mHelper;
};
NS_IMPL_ISUPPORTS0(LookupArgument)
class LookupHelper
: public nsIDNSListener
{
virtual ~LookupHelper()
{
if (mCancel) {
mCancel->Cancel(NS_ERROR_ABORT);
}
}
public:
NS_DECL_THREADSAFE_ISUPPORTS
NS_DECL_NSIDNSLISTENER
LookupHelper() {
}
nsresult ConstructAnswer(LookupArgument *aArgument);
public:
nsCOMPtr<nsICancelable> mCancel;
nsMainThreadPtrHandle<NetDashboardCallback> mCallback;
nsIThread *mThread;
nsresult mStatus;
};
NS_IMPL_ISUPPORTS(LookupHelper, nsIDNSListener)
NS_IMETHODIMP
LookupHelper::OnLookupComplete(nsICancelable *aRequest,
nsIDNSRecord *aRecord, nsresult aStatus)
{
MOZ_ASSERT(aRequest == mCancel);
mCancel = nullptr;
mStatus = aStatus;
RefPtr<LookupArgument> arg = new LookupArgument(aRecord, this);
mThread->Dispatch(NewRunnableMethod<RefPtr<LookupArgument>>
(this, &LookupHelper::ConstructAnswer, arg),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
LookupHelper::ConstructAnswer(LookupArgument *aArgument)
{
nsIDNSRecord *aRecord = aArgument->mRecord;
AutoSafeJSContext cx;
mozilla::dom::DNSLookupDict dict;
dict.mAddress.Construct();
Sequence<nsString> &addresses = dict.mAddress.Value();
if (NS_SUCCEEDED(mStatus)) {
dict.mAnswer = true;
bool hasMore;
aRecord->HasMore(&hasMore);
while (hasMore) {
nsString* nextAddress = addresses.AppendElement(fallible);
if (!nextAddress) {
return NS_ERROR_OUT_OF_MEMORY;
}
nsCString nextAddressASCII;
aRecord->GetNextAddrAsString(nextAddressASCII);
CopyASCIItoUTF16(nextAddressASCII, *nextAddress);
aRecord->HasMore(&hasMore);
}
} else {
dict.mAnswer = false;
GetErrorString(mStatus, dict.mError);
}
JS::RootedValue val(cx);
if (!ToJSValue(cx, dict, &val)) {
return NS_ERROR_FAILURE;
}
this->mCallback->OnDashboardDataAvailable(val);
return NS_OK;
}
NS_IMPL_ISUPPORTS(Dashboard, nsIDashboard, nsIDashboardEventNotifier)
Dashboard::Dashboard()
{
mEnableLogging = false;
}
Dashboard::~Dashboard()
{
}
NS_IMETHODIMP
Dashboard::RequestSockets(NetDashboardCallback *aCallback)
{
RefPtr<SocketData> socketData = new SocketData();
socketData->mCallback =
new nsMainThreadPtrHolder<NetDashboardCallback>(aCallback, true);
socketData->mThread = NS_GetCurrentThread();
gSocketTransportService->Dispatch(NewRunnableMethod<RefPtr<SocketData>>
(this, &Dashboard::GetSocketsDispatch, socketData),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetSocketsDispatch(SocketData *aSocketData)
{
RefPtr<SocketData> socketData = aSocketData;
if (gSocketTransportService) {
gSocketTransportService->GetSocketConnections(&socketData->mData);
socketData->mTotalSent = gSocketTransportService->GetSentBytes();
socketData->mTotalRecv = gSocketTransportService->GetReceivedBytes();
}
socketData->mThread->Dispatch(NewRunnableMethod<RefPtr<SocketData>>
(this, &Dashboard::GetSockets, socketData),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetSockets(SocketData *aSocketData)
{
RefPtr<SocketData> socketData = aSocketData;
AutoSafeJSContext cx;
mozilla::dom::SocketsDict dict;
dict.mSockets.Construct();
dict.mSent = 0;
dict.mReceived = 0;
Sequence<mozilla::dom::SocketElement> &sockets = dict.mSockets.Value();
uint32_t length = socketData->mData.Length();
if (!sockets.SetCapacity(length, fallible)) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
for (uint32_t i = 0; i < socketData->mData.Length(); i++) {
dom::SocketElement &mSocket = *sockets.AppendElement(fallible);
CopyASCIItoUTF16(socketData->mData[i].host, mSocket.mHost);
mSocket.mPort = socketData->mData[i].port;
mSocket.mActive = socketData->mData[i].active;
mSocket.mTcp = socketData->mData[i].tcp;
mSocket.mSent = (double) socketData->mData[i].sent;
mSocket.mReceived = (double) socketData->mData[i].received;
dict.mSent += socketData->mData[i].sent;
dict.mReceived += socketData->mData[i].received;
}
dict.mSent += socketData->mTotalSent;
dict.mReceived += socketData->mTotalRecv;
JS::RootedValue val(cx);
if (!ToJSValue(cx, dict, &val))
return NS_ERROR_FAILURE;
socketData->mCallback->OnDashboardDataAvailable(val);
return NS_OK;
}
NS_IMETHODIMP
Dashboard::RequestHttpConnections(NetDashboardCallback *aCallback)
{
RefPtr<HttpData> httpData = new HttpData();
httpData->mCallback =
new nsMainThreadPtrHolder<NetDashboardCallback>(aCallback, true);
httpData->mThread = NS_GetCurrentThread();
gSocketTransportService->Dispatch(NewRunnableMethod<RefPtr<HttpData>>
(this, &Dashboard::GetHttpDispatch, httpData),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetHttpDispatch(HttpData *aHttpData)
{
RefPtr<HttpData> httpData = aHttpData;
HttpInfo::GetHttpConnectionData(&httpData->mData);
httpData->mThread->Dispatch(NewRunnableMethod<RefPtr<HttpData>>
(this, &Dashboard::GetHttpConnections, httpData),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetHttpConnections(HttpData *aHttpData)
{
RefPtr<HttpData> httpData = aHttpData;
AutoSafeJSContext cx;
mozilla::dom::HttpConnDict dict;
dict.mConnections.Construct();
using mozilla::dom::HalfOpenInfoDict;
using mozilla::dom::HttpConnectionElement;
using mozilla::dom::HttpConnInfo;
Sequence<HttpConnectionElement> &connections = dict.mConnections.Value();
uint32_t length = httpData->mData.Length();
if (!connections.SetCapacity(length, fallible)) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
for (uint32_t i = 0; i < httpData->mData.Length(); i++) {
HttpConnectionElement &connection = *connections.AppendElement(fallible);
CopyASCIItoUTF16(httpData->mData[i].host, connection.mHost);
connection.mPort = httpData->mData[i].port;
connection.mSpdy = httpData->mData[i].spdy;
connection.mSsl = httpData->mData[i].ssl;
connection.mActive.Construct();
connection.mIdle.Construct();
connection.mHalfOpens.Construct();
Sequence<HttpConnInfo> &active = connection.mActive.Value();
Sequence<HttpConnInfo> &idle = connection.mIdle.Value();
Sequence<HalfOpenInfoDict> &halfOpens = connection.mHalfOpens.Value();
if (!active.SetCapacity(httpData->mData[i].active.Length(), fallible) ||
!idle.SetCapacity(httpData->mData[i].idle.Length(), fallible) ||
!halfOpens.SetCapacity(httpData->mData[i].halfOpens.Length(),
fallible)) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
for (uint32_t j = 0; j < httpData->mData[i].active.Length(); j++) {
HttpConnInfo &info = *active.AppendElement(fallible);
info.mRtt = httpData->mData[i].active[j].rtt;
info.mTtl = httpData->mData[i].active[j].ttl;
info.mProtocolVersion =
httpData->mData[i].active[j].protocolVersion;
}
for (uint32_t j = 0; j < httpData->mData[i].idle.Length(); j++) {
HttpConnInfo &info = *idle.AppendElement(fallible);
info.mRtt = httpData->mData[i].idle[j].rtt;
info.mTtl = httpData->mData[i].idle[j].ttl;
info.mProtocolVersion = httpData->mData[i].idle[j].protocolVersion;
}
for (uint32_t j = 0; j < httpData->mData[i].halfOpens.Length(); j++) {
HalfOpenInfoDict &info = *halfOpens.AppendElement(fallible);
info.mSpeculative = httpData->mData[i].halfOpens[j].speculative;
}
}
JS::RootedValue val(cx);
if (!ToJSValue(cx, dict, &val)) {
return NS_ERROR_FAILURE;
}
httpData->mCallback->OnDashboardDataAvailable(val);
return NS_OK;
}
NS_IMETHODIMP
Dashboard::GetEnableLogging(bool *value)
{
*value = mEnableLogging;
return NS_OK;
}
NS_IMETHODIMP
Dashboard::SetEnableLogging(const bool value)
{
mEnableLogging = value;
return NS_OK;
}
NS_IMETHODIMP
Dashboard::AddHost(const nsACString& aHost, uint32_t aSerial, bool aEncrypted)
{
if (mEnableLogging) {
mozilla::MutexAutoLock lock(mWs.lock);
LogData mData(nsCString(aHost), aSerial, aEncrypted);
if (mWs.data.Contains(mData)) {
return NS_OK;
}
if (!mWs.data.AppendElement(mData)) {
return NS_ERROR_OUT_OF_MEMORY;
}
return NS_OK;
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
Dashboard::RemoveHost(const nsACString& aHost, uint32_t aSerial)
{
if (mEnableLogging) {
mozilla::MutexAutoLock lock(mWs.lock);
int32_t index = mWs.IndexOf(nsCString(aHost), aSerial);
if (index == -1)
return NS_ERROR_FAILURE;
mWs.data.RemoveElementAt(index);
return NS_OK;
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
Dashboard::NewMsgSent(const nsACString& aHost, uint32_t aSerial, uint32_t aLength)
{
if (mEnableLogging) {
mozilla::MutexAutoLock lock(mWs.lock);
int32_t index = mWs.IndexOf(nsCString(aHost), aSerial);
if (index == -1)
return NS_ERROR_FAILURE;
mWs.data[index].mMsgSent++;
mWs.data[index].mSizeSent += aLength;
return NS_OK;
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
Dashboard::NewMsgReceived(const nsACString& aHost, uint32_t aSerial, uint32_t aLength)
{
if (mEnableLogging) {
mozilla::MutexAutoLock lock(mWs.lock);
int32_t index = mWs.IndexOf(nsCString(aHost), aSerial);
if (index == -1)
return NS_ERROR_FAILURE;
mWs.data[index].mMsgReceived++;
mWs.data[index].mSizeReceived += aLength;
return NS_OK;
}
return NS_ERROR_FAILURE;
}
NS_IMETHODIMP
Dashboard::RequestWebsocketConnections(NetDashboardCallback *aCallback)
{
RefPtr<WebSocketRequest> wsRequest = new WebSocketRequest();
wsRequest->mCallback =
new nsMainThreadPtrHolder<NetDashboardCallback>(aCallback, true);
wsRequest->mThread = NS_GetCurrentThread();
wsRequest->mThread->Dispatch(NewRunnableMethod<RefPtr<WebSocketRequest>>
(this, &Dashboard::GetWebSocketConnections, wsRequest),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetWebSocketConnections(WebSocketRequest *aWsRequest)
{
RefPtr<WebSocketRequest> wsRequest = aWsRequest;
AutoSafeJSContext cx;
mozilla::dom::WebSocketDict dict;
dict.mWebsockets.Construct();
Sequence<mozilla::dom::WebSocketElement> &websockets =
dict.mWebsockets.Value();
mozilla::MutexAutoLock lock(mWs.lock);
uint32_t length = mWs.data.Length();
if (!websockets.SetCapacity(length, fallible)) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
for (uint32_t i = 0; i < mWs.data.Length(); i++) {
dom::WebSocketElement &websocket = *websockets.AppendElement(fallible);
CopyASCIItoUTF16(mWs.data[i].mHost, websocket.mHostport);
websocket.mMsgsent = mWs.data[i].mMsgSent;
websocket.mMsgreceived = mWs.data[i].mMsgReceived;
websocket.mSentsize = mWs.data[i].mSizeSent;
websocket.mReceivedsize = mWs.data[i].mSizeReceived;
websocket.mEncrypted = mWs.data[i].mEncrypted;
}
JS::RootedValue val(cx);
if (!ToJSValue(cx, dict, &val)) {
return NS_ERROR_FAILURE;
}
wsRequest->mCallback->OnDashboardDataAvailable(val);
return NS_OK;
}
NS_IMETHODIMP
Dashboard::RequestDNSInfo(NetDashboardCallback *aCallback)
{
RefPtr<DnsData> dnsData = new DnsData();
dnsData->mCallback =
new nsMainThreadPtrHolder<NetDashboardCallback>(aCallback, true);
nsresult rv;
dnsData->mData.Clear();
dnsData->mThread = NS_GetCurrentThread();
if (!mDnsService) {
mDnsService = do_GetService("@mozilla.org/network/dns-service;1", &rv);
if (NS_FAILED(rv)) {
return rv;
}
}
gSocketTransportService->Dispatch(NewRunnableMethod<RefPtr<DnsData>>
(this, &Dashboard::GetDnsInfoDispatch, dnsData),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetDnsInfoDispatch(DnsData *aDnsData)
{
RefPtr<DnsData> dnsData = aDnsData;
if (mDnsService) {
mDnsService->GetDNSCacheEntries(&dnsData->mData);
}
dnsData->mThread->Dispatch(NewRunnableMethod<RefPtr<DnsData>>
(this, &Dashboard::GetDNSCacheEntries, dnsData),
NS_DISPATCH_NORMAL);
return NS_OK;
}
nsresult
Dashboard::GetDNSCacheEntries(DnsData *dnsData)
{
AutoSafeJSContext cx;
mozilla::dom::DNSCacheDict dict;
dict.mEntries.Construct();
Sequence<mozilla::dom::DnsCacheEntry> &entries = dict.mEntries.Value();
uint32_t length = dnsData->mData.Length();
if (!entries.SetCapacity(length, fallible)) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
for (uint32_t i = 0; i < dnsData->mData.Length(); i++) {
dom::DnsCacheEntry &entry = *entries.AppendElement(fallible);
entry.mHostaddr.Construct();
Sequence<nsString> &addrs = entry.mHostaddr.Value();
if (!addrs.SetCapacity(dnsData->mData[i].hostaddr.Length(), fallible)) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
CopyASCIItoUTF16(dnsData->mData[i].hostname, entry.mHostname);
entry.mExpiration = dnsData->mData[i].expiration;
for (uint32_t j = 0; j < dnsData->mData[i].hostaddr.Length(); j++) {
nsString* addr = addrs.AppendElement(fallible);
if (!addr) {
JS_ReportOutOfMemory(cx);
return NS_ERROR_OUT_OF_MEMORY;
}
CopyASCIItoUTF16(dnsData->mData[i].hostaddr[j], *addr);
}
if (dnsData->mData[i].family == PR_AF_INET6) {
CopyASCIItoUTF16("ipv6", entry.mFamily);
} else {
CopyASCIItoUTF16("ipv4", entry.mFamily);
}
}
JS::RootedValue val(cx);
if (!ToJSValue(cx, dict, &val)) {
return NS_ERROR_FAILURE;
}
dnsData->mCallback->OnDashboardDataAvailable(val);
return NS_OK;
}
NS_IMETHODIMP
Dashboard::RequestDNSLookup(const nsACString &aHost,
NetDashboardCallback *aCallback)
{
nsresult rv;
if (!mDnsService) {
mDnsService = do_GetService("@mozilla.org/network/dns-service;1", &rv);
if (NS_FAILED(rv)) {
return rv;
}
}
RefPtr<LookupHelper> helper = new LookupHelper();
helper->mCallback =
new nsMainThreadPtrHolder<NetDashboardCallback>(aCallback, true);
helper->mThread = NS_GetCurrentThread();
OriginAttributes attrs;
rv = mDnsService->AsyncResolveNative(aHost, 0, helper.get(),
NS_GetCurrentThread(), attrs,
getter_AddRefs(helper->mCancel));
return rv;
}
void
HttpConnInfo::SetHTTP1ProtocolVersion(uint8_t pv)
{
switch (pv) {
case NS_HTTP_VERSION_0_9:
protocolVersion.AssignLiteral(u"http/0.9");
break;
case NS_HTTP_VERSION_1_0:
protocolVersion.AssignLiteral(u"http/1.0");
break;
case NS_HTTP_VERSION_1_1:
protocolVersion.AssignLiteral(u"http/1.1");
break;
case NS_HTTP_VERSION_2_0:
protocolVersion.AssignLiteral(u"http/2.0");
break;
default:
protocolVersion.AssignLiteral(u"unknown protocol version");
}
}
void
HttpConnInfo::SetHTTP2ProtocolVersion(uint8_t pv)
{
MOZ_ASSERT (pv == HTTP_VERSION_2);
protocolVersion.Assign(u"h2");
}
NS_IMETHODIMP
Dashboard::GetLogPath(nsACString &aLogPath)
{
aLogPath.SetCapacity(2048);
uint32_t len = LogModule::GetLogFile(aLogPath.BeginWriting(), 2048);
aLogPath.SetLength(len);
return NS_OK;
}
NS_IMETHODIMP
Dashboard::RequestConnection(const nsACString& aHost, uint32_t aPort,
const char *aProtocol, uint32_t aTimeout,
NetDashboardCallback *aCallback)
{
nsresult rv;
RefPtr<ConnectionData> connectionData = new ConnectionData(this);
connectionData->mHost = aHost;
connectionData->mPort = aPort;
connectionData->mProtocol = aProtocol;
connectionData->mTimeout = aTimeout;
connectionData->mCallback =
new nsMainThreadPtrHolder<NetDashboardCallback>(aCallback, true);
connectionData->mThread = NS_GetCurrentThread();
rv = TestNewConnection(connectionData);
if (NS_FAILED(rv)) {
mozilla::net::GetErrorString(rv, connectionData->mStatus);
connectionData->mThread->Dispatch(NewRunnableMethod<RefPtr<ConnectionData>>
(this, &Dashboard::GetConnectionStatus, connectionData),
NS_DISPATCH_NORMAL);
return rv;
}
return NS_OK;
}
nsresult
Dashboard::GetConnectionStatus(ConnectionData *aConnectionData)
{
RefPtr<ConnectionData> connectionData = aConnectionData;
AutoSafeJSContext cx;
mozilla::dom::ConnStatusDict dict;
dict.mStatus = connectionData->mStatus;
JS::RootedValue val(cx);
if (!ToJSValue(cx, dict, &val))
return NS_ERROR_FAILURE;
connectionData->mCallback->OnDashboardDataAvailable(val);
return NS_OK;
}
nsresult
Dashboard::TestNewConnection(ConnectionData *aConnectionData)
{
RefPtr<ConnectionData> connectionData = aConnectionData;
nsresult rv;
if (!connectionData->mHost.Length() ||
!net_IsValidHostName(connectionData->mHost)) {
return NS_ERROR_UNKNOWN_HOST;
}
if (connectionData->mProtocol &&
NS_LITERAL_STRING("ssl").EqualsASCII(connectionData->mProtocol)) {
rv = gSocketTransportService->CreateTransport(
&connectionData->mProtocol, 1, connectionData->mHost,
connectionData->mPort, nullptr,
getter_AddRefs(connectionData->mSocket));
} else {
rv = gSocketTransportService->CreateTransport(
nullptr, 0, connectionData->mHost,
connectionData->mPort, nullptr,
getter_AddRefs(connectionData->mSocket));
}
if (NS_FAILED(rv)) {
return rv;
}
rv = connectionData->mSocket->SetEventSink(connectionData,
NS_GetCurrentThread());
if (NS_FAILED(rv)) {
return rv;
}
rv = connectionData->mSocket->OpenInputStream(
nsITransport::OPEN_BLOCKING, 0, 0,
getter_AddRefs(connectionData->mStreamIn));
if (NS_FAILED(rv)) {
return rv;
}
connectionData->StartTimer(connectionData->mTimeout);
return rv;
}
typedef struct
{
nsresult key;
const char *error;
} ErrorEntry;
#undef ERROR
#define ERROR(key, val) {key, #key}
ErrorEntry socketTransportStatuses[] = {
ERROR(NS_NET_STATUS_RESOLVING_HOST, FAILURE(3)),
ERROR(NS_NET_STATUS_RESOLVED_HOST, FAILURE(11)),
ERROR(NS_NET_STATUS_CONNECTING_TO, FAILURE(7)),
ERROR(NS_NET_STATUS_CONNECTED_TO, FAILURE(4)),
ERROR(NS_NET_STATUS_TLS_HANDSHAKE_STARTING, FAILURE(12)),
ERROR(NS_NET_STATUS_TLS_HANDSHAKE_ENDED, FAILURE(13)),
ERROR(NS_NET_STATUS_SENDING_TO, FAILURE(5)),
ERROR(NS_NET_STATUS_WAITING_FOR, FAILURE(10)),
ERROR(NS_NET_STATUS_RECEIVING_FROM, FAILURE(6)),
};
#undef ERROR
static void
GetErrorString(nsresult rv, nsAString& errorString)
{
for (size_t i = 0; i < ArrayLength(socketTransportStatuses); ++i) {
if (socketTransportStatuses[i].key == rv) {
errorString.AssignASCII(socketTransportStatuses[i].error);
return;
}
}
nsAutoCString errorCString;
mozilla::GetErrorName(rv, errorCString);
CopyUTF8toUTF16(errorCString, errorString);
}
} // namespace net
} // namespace mozilla
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку