bool
ProxyAutoConfig::SrcAddress(const NetAddr *remoteAddress, nsCString &localAddress)
{
PRFileDesc *fd;
fd = PR_OpenUDPSocket(remoteAddress->raw.family);
if (!fd)
return false;
PRNetAddr prRemoteAddress;
NetAddrToPRNetAddr(remoteAddress, &prRemoteAddress);
if (PR_Connect(fd, &prRemoteAddress, 0) != PR_SUCCESS) {
PR_Close(fd);
return false;
}
PRNetAddr localName;
if (PR_GetSockName(fd, &localName) != PR_SUCCESS) {
PR_Close(fd);
return false;
}
PR_Close(fd);
char dottedDecimal[128];
if (PR_NetAddrToString(&localName, dottedDecimal, sizeof(dottedDecimal)) != PR_SUCCESS)
return false;
localAddress.Assign(dottedDecimal);
return true;
}
nsresult
Tickler::Init()
{
MOZ_ASSERT(NS_IsMainThread());
MOZ_ASSERT(!mTimer);
MOZ_ASSERT(!mActive);
MOZ_ASSERT(!mThread);
MOZ_ASSERT(!mFD);
if (AndroidBridge::HasEnv()) {
GeckoAppShell::EnableNetworkNotifications();
}
mFD = PR_OpenUDPSocket(PR_AF_INET);
if (!mFD)
return NS_ERROR_FAILURE;
// make sure new socket has a ttl of 1
// failure is not fatal.
PRSocketOptionData opt;
opt.option = PR_SockOpt_IpTimeToLive;
opt.value.ip_ttl = 1;
PR_SetSocketOption(mFD, &opt);
nsresult rv = NS_NewNamedThread("wifi tickler",
getter_AddRefs(mThread));
if (NS_FAILED(rv))
return rv;
nsCOMPtr<nsITimer> tmpTimer(do_CreateInstance(NS_TIMER_CONTRACTID, &rv));
if (NS_FAILED(rv))
return rv;
rv = tmpTimer->SetTarget(mThread);
if (NS_FAILED(rv))
return rv;
mTimer.swap(tmpTimer);
mAddr.inet.family = PR_AF_INET;
mAddr.inet.port = PR_htons (4886);
mAddr.inet.ip = 0;
return NS_OK;
}
NS_IMETHODIMP
nsUDPSocketProvider::NewSocket(int32_t aFamily,
const char *aHost,
int32_t aPort,
const char *aProxyHost,
int32_t aProxyPort,
uint32_t aFlags,
PRFileDesc * *aFileDesc,
nsISupports **aSecurityInfo)
{
NS_ENSURE_ARG_POINTER(aFileDesc);
PRFileDesc* udpFD = PR_OpenUDPSocket(aFamily);
if (!udpFD)
return NS_ERROR_FAILURE;
*aFileDesc = udpFD;
return NS_OK;
}
UDPPusher::UDPPusher(const char *filename, unsigned port)
: mFile(fopen(filename, "rb")),
mFirstTimeMs(0),
mFirstTimeUs(0) {
CHECK(mFile != NULL);
mSocket = PR_OpenUDPSocket(PR_AF_INET);
if (!mSocket) {
TRESPASS();
}
NetworkActivityMonitor::AttachIOLayer(mSocket);
PRNetAddr addr;
addr.inet.family = PR_AF_INET;
addr.inet.ip = PR_htonl(PR_INADDR_ANY);
addr.inet.port = PR_htons(0);
CHECK_EQ(PR_SUCCESS, PR_Bind(mSocket, &addr));
mRemoteAddr.inet.family = PR_AF_INET;
mRemoteAddr.inet.ip = PR_htonl(PR_INADDR_ANY);
mRemoteAddr.inet.port = PR_htons(port);
}
int
main(int argc, char* argv[])
{
if (test_common_init(&argc, &argv) != 0)
return -1;
int returnCode = 0;
nsresult rv = NS_OK;
PRFileDesc *serverFD = nullptr;
do { // act both as a scope for nsCOMPtrs to be released before XPCOM
// shutdown, as well as a easy way to abort the test
PRStatus status = PR_SUCCESS;
nsCOMPtr<nsIServiceManager> servMan;
NS_InitXPCOM2(getter_AddRefs(servMan), nullptr, nullptr);
nsCOMPtr<nsIComponentRegistrar> registrar = do_QueryInterface(servMan);
UDP_ASSERT(registrar, "Null nsIComponentRegistrar");
if (registrar)
registrar->AutoRegister(nullptr);
// listen for a incoming UDP connection on localhost
serverFD = PR_OpenUDPSocket(PR_AF_INET);
UDP_ASSERT(serverFD, "Cannot open UDP socket for listening");
PRSocketOptionData socketOptions;
socketOptions.option = PR_SockOpt_Nonblocking;
socketOptions.value.non_blocking = false;
status = PR_SetSocketOption(serverFD, &socketOptions);
UDP_ASSERT_PRSTATUS("Failed to set server socket as blocking");
PRNetAddr addr;
status = PR_InitializeNetAddr(PR_IpAddrLoopback, UDP_PORT, &addr);
UDP_ASSERT_PRSTATUS("Failed to initialize loopback address");
status = PR_Bind(serverFD, &addr);
UDP_ASSERT_PRSTATUS("Failed to bind server socket");
// dummy IOService to get around bug 379890
nsCOMPtr<nsISupports> ios =
do_GetService("@mozilla.org/network/io-service;1");
// and have a matching UDP connection for the client
nsCOMPtr<nsISocketTransportService> sts =
do_GetService("@mozilla.org/network/socket-transport-service;1", &rv);
UDP_ASSERT_NSRESULT("Cannot get socket transport service");
nsCOMPtr<nsISocketTransport> transport;
const char *protocol = "udp";
rv = sts->CreateTransport(&protocol, 1, NS_LITERAL_CSTRING("localhost"),
UDP_PORT, nullptr, getter_AddRefs(transport));
UDP_ASSERT_NSRESULT("Cannot create transport");
uint32_t count, read;
const uint32_t data = 0xFF0056A9;
// write to the output stream
nsCOMPtr<nsIOutputStream> outstream;
rv = transport->OpenOutputStream(nsITransport::OPEN_BLOCKING,
0, 0, getter_AddRefs(outstream));
UDP_ASSERT_NSRESULT("Cannot open output stream");
rv = outstream->Write((const char*)&data, sizeof(uint32_t), &count);
UDP_ASSERT_NSRESULT("Cannot write to output stream");
UDP_ASSERT(count == sizeof(uint32_t),
"Did not write enough bytes to output stream");
// read from NSPR to check it's the same
count = PR_RecvFrom(serverFD, &read, sizeof(uint32_t), 0, &addr, 1);
UDP_ASSERT(count == sizeof(uint32_t),
"Did not read enough bytes from NSPR");
status = (read == data ? PR_SUCCESS : PR_FAILURE);
UDP_ASSERT_PRSTATUS("Did not read expected data from NSPR");
// write to NSPR
count = PR_SendTo(serverFD, &data, sizeof(uint32_t), 0, &addr, 1);
status = (count == sizeof(uint32_t) ? PR_SUCCESS : PR_FAILURE);
UDP_ASSERT_PRSTATUS("Did not write enough bytes to NSPR");
// read from stream
nsCOMPtr<nsIInputStream> instream;
rv = transport->OpenInputStream(nsITransport::OPEN_BLOCKING,
0, 0, getter_AddRefs(instream));
UDP_ASSERT_NSRESULT("Cannot open input stream");
rv = instream->Read((char*)&read, sizeof(uint32_t), &count);
UDP_ASSERT_NSRESULT("Cannot read from input stream");
UDP_ASSERT(count == sizeof(uint32_t),
"Did not read enough bytes from input stream");
UDP_ASSERT(read == data, "Did not read expected data from stream");
} while (false); // release all XPCOM things
if (serverFD) {
PRStatus status = PR_Close(serverFD);
if (status != PR_SUCCESS) {
PRErrorCode err = PR_GetError();
fprintf(stderr, "FAIL: Cannot close server: (%08x) %s\n",
err, PR_ErrorToString(err, PR_LANGUAGE_I_DEFAULT));
}
}
rv = NS_ShutdownXPCOM(nullptr);
NS_ASSERTION(NS_SUCCEEDED(rv), "NS_ShutdownXPCOM failed");
return returnCode;
}
