Magic-Mirror/gecko-dev
1
0
Fork 0
mirror of https://github.com/mozilla/gecko-dev.git synced 2024-10-31 14:15:30 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity
eb5d84d267
gecko-dev/network/module/nsNetService.cpp
mscott%netscape.com 02cedbd20b Add socket transport support to the nsINetService interface.
1999-01-28 01:57:30 +00:00

1560 lines
41 KiB
C++
Raw Blame History

/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*-
*
* The contents of this file are subject to the Netscape Public License
* Version 1.0 (the "License"); you may not use this file except in
* compliance with the License. You may obtain a copy of the License at
* http://www.mozilla.org/NPL/
*
* Software distributed under the License is distributed on an "AS IS"
* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See
* the License for the specific language governing rights and limitations
* under the License.
*
* The Original Code is Mozilla Communicator client code.
*
* The Initial Developer of the Original Code is Netscape Communications
* Corporation. Portions created by Netscape are Copyright (C) 1998
* Netscape Communications Corporation. All Rights Reserved.
*/
#include "nsRepository.h"
#include "nsITimer.h"
#include "nsNetService.h"
#include "nsNetStream.h"
#include "nsNetFile.h"
#include "nsStubContext.h"
#include "prefapi.h"
#include "mkprefs.h"
extern "C" {
#include "mkutils.h"
#include "mkgeturl.h"
#include "mktrace.h"
#include "mkstream.h"
#include "cvchunk.h"
#include "httpurl.h"
} /* end of extern "C" */
#include "netcache.h"
#include "cookies.h"
#include "plstr.h"
#include "nsString.h"
#include "nsINetlibURL.h"
#include "nsIProtocolConnection.h"
#include "nsIProtocolURLFactory.h"
#include "nsIProtocol.h"
#include "nsIURLGroup.h"
#include "nsIServiceManager.h"
#include "nsIEventQueueService.h"
#include "nsXPComCIID.h"
#include "nsCRT.h"
#include "nsSocketTransport.h"
#ifdef XP_PC
#include <windows.h>
static HINSTANCE g_hInst = NULL;
#endif
/*
** Define TIMEBOMB_ON for beta builds.
** Undef TIMEBOMB_ON for release builds.
*/
/*#define TIMEBOMB_ON*/
#undef TIMEBOMB_ON
/*
** After this date all hell breaks loose
*/
#ifdef TIMEBOMB_ON
#define TIME_BOMB_TIME 917856001 /* 2/01/98 + 1 secs */
#define TIME_BOMB_WARNING_TIME 915955201 /* 1/10/98 + 1 secs */
#else
#define TIME_BOMB_TIME -1
#define TIME_BOMB_WARNING_TIME -1
#endif
// Declare the nsFile struct here so it's state is initialized before
// we initialize netlib.
#ifdef NS_NET_FILE
#include "nsNetFile.h"
#ifdef XP_MAC
static nsNetFileInit* netFileInit = nsnull;
#else
static nsNetFileInit netFileInit;
#endif
#endif // NS_NET_FILE
// End nsFile specific
/* XXX: Legacy definitions... */
// Global count of active urls from mkgeturl.c
extern "C" int NET_TotalNumberOfProcessingURLs;
extern "C" HTTP_Version DEFAULT_VERSION;
extern "C" void net_AddrefContext(MWContext* window_id);
static void bam_exit_routine(URL_Struct *URL_s, int status, MWContext *window_id);
#if defined(XP_WIN) && !defined(NETLIB_THREAD)
nsresult PerformNastyWindowsAsyncDNSHack(URL_Struct* URL_s, nsIURL* aURL);
#endif /* XP_WIN && !NETLIB_THREAD */
char *mangleResourceIntoFileURL(const char* aResourceFileName) ;
extern nsIStreamListener* ns_NewStreamListenerProxy(nsIStreamListener* aListener, PLEventQueue* aEventQ);
extern "C" {
#if defined(XP_WIN) || defined(XP_OS2)
extern char *XP_AppCodeName;
extern char *XP_AppVersion;
extern char *XP_AppName;
extern char *XP_AppLanguage;
extern char *XP_AppPlatform;
#else
extern const char *XP_AppCodeName;
extern const char *XP_AppVersion;
extern const char *XP_AppName;
extern const char *XP_AppLanguage;
extern const char *XP_AppPlatform;
#endif
} /* end of extern "C" */
static NS_DEFINE_IID(kINetlibURLIID, NS_INETLIBURL_IID);
static NS_DEFINE_IID(kEventQueueServiceCID, NS_EVENTQUEUESERVICE_CID);
static NS_DEFINE_IID(kIEventQueueServiceIID, NS_IEVENTQUEUESERVICE_IID);
nsNetlibService::nsNetlibService()
{
nsresult rv;
NS_INIT_REFCNT();
/*
* Cache the EventQueueService...
*/
// XXX: What if this fails?
mEventQService = nsnull;
rv = nsServiceManager::GetService(kEventQueueServiceCID,
kIEventQueueServiceIID,
(nsISupports **)&mEventQService);
/*
m_stubContext = new_stub_context();
*/
mPollingTimer = nsnull;
mNetlibThread = new nsNetlibThread();
if (nsnull != mNetlibThread) {
mNetlibThread->Start();
}
/* Setup our default prefs. Eventually these will come out of a default
* all.js file, but, for now each module needs to address their own
* default settings. */
PREF_SetDefaultIntPref(pref_proxyType, 3);
PREF_SetDefaultCharPref(pref_proxyACUrl, "");
PREF_SetDefaultCharPref(pref_socksServer, "");
PREF_SetDefaultIntPref(pref_socksPort, 0);
PREF_SetDefaultCharPref(pref_proxyFtpServer, "");
PREF_SetDefaultIntPref(pref_proxyFtpPort, 0);
PREF_SetDefaultCharPref(pref_proxyGopherServer, "");
PREF_SetDefaultIntPref(pref_proxyGopherPort, 0);
PREF_SetDefaultCharPref(pref_proxyHttpServer, "");
PREF_SetDefaultIntPref(pref_proxyHttpPort, 0);
PREF_SetDefaultCharPref(pref_proxyNewsServer, "");
PREF_SetDefaultIntPref(pref_proxyNewsPort, 0);
PREF_SetDefaultCharPref(pref_proxyWaisServer, "");
PREF_SetDefaultIntPref(pref_proxyWaisPort, 0);
PREF_SetDefaultCharPref(pref_proxyNoProxiesOn, "");
PREF_SetDefaultCharPref(pref_padPacURL, "");
PREF_SetDefaultCharPref(pref_scriptName, "");
PREF_SetDefaultIntPref("timebomb.expiration_time",TIME_BOMB_TIME);
PREF_SetDefaultIntPref("timebomb.warning_time", TIME_BOMB_WARNING_TIME);
// XXX: Where should the defaults really come from
XP_AppCodeName = PL_strdup("Mozilla");
XP_AppName = PL_strdup("Netscape");
/*
* XXX: Some of these should come from resources and/or
* platform-specific code.
*/
XP_AppLanguage = PL_strdup("en");
#ifdef XP_WIN
XP_AppPlatform = PL_strdup("Win95");
#elif defined(XP_MAC)
XP_AppPlatform = PL_strdup("MacPPC");
#elif defined(XP_UNIX)
/* XXX: Need to differentiate between various Unisys */
XP_AppPlatform = PL_strdup("Unix");
#endif
/* XXXXX TEMPORARY TESTING HACK XXXXX */
char buf[64];
char *ver = PR_GetEnv("NG_REQUEST_VER");
/* Build up the appversion. */
sprintf(buf, "%s [%s] (%s; I)",
(ver ? ver : "5.0"),
XP_AppLanguage,
XP_AppPlatform);
if (XP_AppVersion)
PR_Free((char *)XP_AppVersion);
XP_AppVersion = PL_strdup(buf);
mProtocols = new nsHashtable();
PR_ASSERT(mProtocols);
}
static NS_DEFINE_IID(kINetServiceIID, NS_INETSERVICE_IID);
NS_IMPL_THREADSAFE_ISUPPORTS(nsNetlibService,kINetServiceIID);
nsNetlibService::~nsNetlibService()
{
TRACEMSG(("nsNetlibService is being destroyed...\n"));
/*
if (NULL != m_stubContext) {
free_stub_context((MWContext *)m_stubContext);
m_stubContext = NULL;
}
*/
NS_IF_RELEASE(mPollingTimer);
if (nsnull != mNetlibThread) {
mNetlibThread->Stop();
delete mNetlibThread;
}
if (nsnull != mEventQService) {
nsServiceManager::ReleaseService(kEventQueueServiceCID, mEventQService);
mEventQService = nsnull;
}
delete mProtocols;
}
void nsNetlibService::SetupURLStruct(nsIURL *aUrl, URL_Struct *aURL_s)
{
nsresult rv;
nsILoadAttribs* loadAttribs;
rv = aUrl->GetLoadAttribs(&loadAttribs);
/* If this url has load attributes, setup the underlying url struct
* accordingly. */
if (loadAttribs) {
nsURLLoadType loadType;
nsURLReloadType reloadType;
PRUint32 localIP;
char* byteRangeHeader=NULL;
NS_VERIFY_THREADSAFE_INTERFACE(loadAttribs);
rv = loadAttribs->GetReloadType(&reloadType);
if (NS_FAILED(rv)) {
reloadType = nsURLReload;
}
if ((reloadType == nsURLReloadBypassProxy) ||
(reloadType == nsURLReloadBypassCacheAndProxy)) {
PRBool bBypassProxy;
rv = loadAttribs->GetBypassProxy(&bBypassProxy);
if (NS_FAILED(rv)) {
bBypassProxy = PR_FALSE;
}
aURL_s->bypassProxy = bBypassProxy;
}
/* Set the NET_ReloadMethod to correspond with what we've
* been asked to do.
*
* 0 = nsURLReload (normal)
* 1 = nsURLReloadBypassCache
* 2 = nsURLReloadBypassProxy
* 3 = nsURLReloadBypassCacheAndProxy
*/
if ((reloadType == nsURLReloadBypassCache) ||
(reloadType == nsURLReloadBypassCacheAndProxy)) {
aURL_s->force_reload = NET_SUPER_RELOAD;
} else {
aURL_s->force_reload = NET_NORMAL_RELOAD;
}
rv = loadAttribs->GetLoadType(&loadType);
if (NS_FAILED(rv)) {
loadType = nsURLLoadNormal;
}
if (loadType == nsURLLoadBackground) {
aURL_s->load_background = PR_TRUE;
} else {
aURL_s->load_background = PR_FALSE;
}
rv = loadAttribs->GetLocalIP(&localIP);
if (NS_FAILED(rv)) {
localIP = 0;
}
aURL_s->localIP = localIP;
rv = loadAttribs->GetByteRangeHeader(&byteRangeHeader);
if (NS_FAILED(rv))
{
byteRangeHeader = NULL;
}
else
{
aURL_s->range_header = byteRangeHeader;
}
NS_RELEASE(loadAttribs);
}
}
nsresult nsNetlibService::OpenStream(nsIURL *aUrl,
nsIStreamListener *aConsumer)
{
URL_Struct *URL_s;
nsConnectionInfo *pConn;
nsINetlibURL *netlibURL;
nsresult result;
nsIStreamListener* consumer;
PLEventQueue* evQueue = nsnull;
if ((NULL == aConsumer) || (NULL == aUrl)) {
return NS_FALSE;
}
#if defined(NETLIB_THREAD)
if (nsnull != mEventQService) {
mEventQService->GetThreadEventQueue(PR_GetCurrentThread(), &evQueue);
}
if (nsnull == evQueue) {
return NS_FALSE;
}
consumer = ns_NewStreamListenerProxy(aConsumer, evQueue);
if (nsnull == consumer) {
return NS_FALSE;
}
#else
consumer = aConsumer;
#endif
/* Create the nsConnectionInfo object... */
pConn = new nsConnectionInfo(aUrl, NULL, consumer);
if (NULL == pConn) {
return NS_FALSE;
}
NS_ADDREF(pConn);
/*
* XXX: Rewrite the resource: URL into a file: URL
*/
const char* protocol;
result = aUrl->GetProtocol(&protocol);
NS_ASSERTION(result == NS_OK, "deal with this");
if (PL_strcmp(protocol, "resource") == 0) {
char* fileName;
const char* file;
result = aUrl->GetFile(&file);
NS_ASSERTION(result == NS_OK, "deal with this");
fileName = mangleResourceIntoFileURL(file);
aUrl->SetSpec(fileName);
PR_Free(fileName);
}
/* Create the URLStruct... */
const char* spec = NULL;
result = aUrl->GetSpec(&spec);
NS_ASSERTION(result == NS_OK, "deal with this");
URL_s = NET_CreateURLStruct(spec, NET_NORMAL_RELOAD);
if (NULL == URL_s) {
NS_RELEASE(pConn);
return NS_FALSE;
}
SetupURLStruct(aUrl, URL_s);
/*
* Attach the Data Consumer to the URL_Struct.
*
* Both the Data Consumer and the URL_Struct are freed in the
* bam_exit_routine(...)
*
* The Reference count on pConn is already 1 so no AddRef() is necessary.
*/
URL_s->fe_data = pConn;
/*
* Attach the Event Queue to use when proxying data back to the thread
* which initiated the URL load...
*
* Currently, this information is needed to marshall the call to the URL
* exit_routine(...) on the correct thread...
*/
URL_s->owner_data = evQueue;
/*
* Give the protocol a chance to initialize any URL_Struct fields...
*
* XXX: Currently the return value form InitializeURLInfo(...) is
* ignored... Should the connection abort if it fails?
*/
result = aUrl->QueryInterface(kINetlibURLIID, (void**)&netlibURL);
if (NS_OK == result) {
netlibURL->SetURLInfo(URL_s);
NS_RELEASE(netlibURL);
}
/* Create a new Context and set its reference count to one.. */
MWContext *stubContext = new_stub_context(URL_s);
net_AddrefContext(stubContext);
/* Check for timebomb...*/
#ifdef TIMEBOMB_ON
NET_CheckForTimeBomb(stubContext);
#endif /* TIMEBOMB_ON */
/* Start the URL load... */
NET_GetURL (URL_s, /* URL_Struct */
FO_CACHE_AND_NGLAYOUT, /* FO_Present_type */
(MWContext *)stubContext, /* MWContext */
bam_exit_routine); /* Exit routine... */
/* Remember, the URL_s may have been freed ! */
/*
* Start the network timer to call NET_PollSockets(...) until the
* URL has been completely loaded...
*/
SchedulePollingTimer();
return NS_OK;
}
nsresult nsNetlibService::OpenBlockingStream(nsIURL *aUrl,
nsIStreamListener *aConsumer,
nsIInputStream **aNewStream)
{
URL_Struct *URL_s;
nsConnectionInfo *pConn;
nsNetlibStream *pBlockingStream;
nsINetlibURL *netlibURL;
nsIStreamListener* consumer = nsnull;
PLEventQueue* evQueue = nsnull;
nsresult result;
if (NULL == aNewStream) {
return NS_FALSE;
}
if (NULL != aUrl) {
#if defined(NETLIB_THREAD)
if (nsnull != mEventQService) {
mEventQService->GetThreadEventQueue(PR_GetCurrentThread(), &evQueue);
}
if (nsnull == evQueue) {
goto loser;
}
if (nsnull != aConsumer) {
consumer = ns_NewStreamListenerProxy(aConsumer, evQueue);
if (nsnull == consumer) {
goto loser;
}
}
#else
consumer = aConsumer;
#endif
/* Create the blocking stream... */
pBlockingStream = new nsBlockingStream();
if (NULL == pBlockingStream) {
goto loser;
}
/*
* AddRef the new stream in anticipation of returning it... This will
* keep it alive :-)
*/
NS_ADDREF(pBlockingStream);
/* Create the nsConnectionInfo object... */
pConn = new nsConnectionInfo(aUrl, pBlockingStream, consumer);
if (NULL == pConn) {
NS_RELEASE(pBlockingStream);
goto loser;
}
NS_ADDREF(pConn);
/*
* XXX: Rewrite the resource: URL into a file: URL
*/
const char* protocol;
result = aUrl->GetProtocol(&protocol);
NS_ASSERTION(result == NS_OK, "deal with this");
if (PL_strcmp(protocol, "resource") == 0) {
char* fileName;
const char* file;
result = aUrl->GetFile(&file);
NS_ASSERTION(result == NS_OK, "deal with this");
fileName = mangleResourceIntoFileURL(file);
aUrl->SetSpec(fileName);
PR_Free(fileName);
}
/* Create the URLStruct... */
const char* spec = NULL;
result = aUrl->GetSpec(&spec);
NS_ASSERTION(result == NS_OK, "deal with this");
URL_s = NET_CreateURLStruct(spec, NET_NORMAL_RELOAD);
if (NULL == URL_s) {
NS_RELEASE(pBlockingStream);
NS_RELEASE(pConn);
goto loser;
}
SetupURLStruct(aUrl, URL_s);
#if defined(XP_WIN) && !defined(NETLIB_THREAD)
/*
* When opening a blocking HTTP stream, perform a synchronous DNS
* lookup now, to avoid netlib from doing an async lookup later
* and causing a deadlock!
*/
result = PerformNastyWindowsAsyncDNSHack(URL_s, aUrl);
if (NS_OK != result) {
NET_FreeURLStruct(URL_s);
NS_RELEASE(pBlockingStream);
NS_RELEASE(pConn);
goto loser;
}
#endif /* XP_WIN && !NETLIB_THREAD */
/*
* Attach the ConnectionInfo object to the URL_Struct.
*
* Both the ConnectionInfo and the URL_Struct are freed in the
* bam_exit_routine(...)
* The Reference count on pConn is already 1 so no AddRef() is
* necessary.
*/
URL_s->fe_data = pConn;
/*
* Attach the Event Queue to use when proxying data back to the thread
* which initiated the URL load...
*
* Currently, this information is needed to marshall the call to the URL
* exit_routine(...) on the correct thread...
*/
URL_s->owner_data = evQueue;
/*
* Give the protocol a chance to initialize any URL_Struct fields...
*
* XXX: Currently the return value form InitializeURLInfo(...) is
* ignored... Should the connection abort if it fails?
*/
result = aUrl->QueryInterface(kINetlibURLIID, (void**)&netlibURL);
if (NS_OK == result) {
netlibURL->SetURLInfo(URL_s);
NS_RELEASE(netlibURL);
}
/* printf("+++ Loading %s\n", aUrl); */
/* Create a new Context and set its reference count to one.. */
MWContext *stubContext = new_stub_context(URL_s);
net_AddrefContext(stubContext);
/* Check for timebomb...*/
#ifdef TIMEBOMB_ON
NET_CheckForTimeBomb(stubContext);
#endif /* TIMEBOMB_ON */
/* Start the URL load... */
NET_GetURL (URL_s, /* URL_Struct */
FO_CACHE_AND_NGLAYOUT, /* FO_Present_type */
(MWContext *) stubContext, /* MWContext */
bam_exit_routine); /* Exit routine... */
/* Remember, the URL_s may have been freed ! */
/*
* Start the network timer to call NET_PollSockets(...) until the
* URL has been completely loaded...
*/
SchedulePollingTimer();
*aNewStream = pBlockingStream;
return NS_OK;
}
loser:
*aNewStream = NULL;
return NS_FALSE;
}
static NS_DEFINE_IID(kIProtocolConnectionIID, NS_IPROTOCOLCONNECTION_IID);
NS_IMETHODIMP
nsNetlibService::InterruptStream(nsIURL* aURL)
{
nsIProtocolConnection *pProtocol;
nsresult rv = NS_OK;
if (nsnull == aURL) {
rv = NS_ERROR_NULL_POINTER;
goto done;
}
rv = aURL->QueryInterface(kIProtocolConnectionIID, (void**)&pProtocol);
if (NS_SUCCEEDED(rv)) {
URL_Struct* URL_s;
int status = -1;
pProtocol->GetURLInfo(&URL_s);
if (nsnull != URL_s) {
status = NET_InterruptStream(URL_s);
}
NS_RELEASE(pProtocol);
if (status != 0) {
rv = NS_ERROR_FAILURE;
}
}
done:
return rv;
}
NS_IMETHODIMP
nsNetlibService::GetCookieString(nsIURL *aURL, nsString& aCookie)
{
// XXX How safe is it to create a stub context without a URL_Struct?
MWContext *stubContext = new_stub_context(nsnull);
const char *spec = NULL;
nsresult result = aURL->GetSpec(&spec);
NS_ASSERTION(result == NS_OK, "deal with this");
char *cookie = NET_GetCookie(stubContext, (char *)spec);
if (nsnull != cookie) {
aCookie.SetString(cookie);
PR_FREEIF(cookie);
}
else {
aCookie.SetString("");
}
free_stub_context(stubContext);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SetCookieString(nsIURL *aURL, const nsString& aCookie)
{
// XXX How safe is it to create a stub context without a URL_Struct?
MWContext *stubContext = new_stub_context(nsnull);
const char *spec = NULL;
nsresult result = aURL->GetSpec(&spec);
NS_ASSERTION(result == NS_OK, "deal with this");
char *cookie = aCookie.ToNewCString();
NET_SetCookieString(stubContext, (char *)spec, cookie);
delete []cookie;
free_stub_context(stubContext);
return NS_OK;
}
#ifdef SingleSignon
NS_IMETHODIMP
nsNetlibService::SI_DisplaySignonInfoAsHTML(){
::SI_DisplaySignonInfoAsHTML(NULL);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SI_RememberSignonData
(char* URLName, LO_FormSubmitData *submit) {
::SI_RememberSignonData(URLName, submit);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SI_RestoreSignonData
(char* URLName, char* name, char** value) {
::SI_RestoreSignonData(URLName, name, value);
return NS_OK;
}
#endif
#ifdef CookieManagement
NS_IMETHODIMP
nsNetlibService::NET_DisplayCookieInfoAsHTML(){
::NET_DisplayCookieInfoAsHTML(NULL);
return NS_OK;
}
#ifdef PrivacySiteInfo
NS_IMETHODIMP
nsNetlibService::NET_DisplayCookieInfoOfSiteAsHTML(char * URLName){
::NET_DisplayCookieInfoOfSiteAsHTML(NULL, URLName);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::NET_CookiePermission(char* URLName, PRInt32* permission){
*permission = ::NET_CookiePermission(URLName);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::NET_CookieCount(char* URLName, PRInt32* count){
*count = ::NET_CookieCount(URLName);
return NS_OK;
}
#endif
#endif
NS_IMETHODIMP
nsNetlibService::NET_AnonymizeCookies(){
#ifdef CookieManagement
::NET_AnonymizeCookies();
#endif
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::NET_UnanonymizeCookies(){
#ifdef CookieManagement
::NET_UnanonymizeCookies();
#endif
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SI_AnonymizeSignons(){
#ifdef SingleSignon
::SI_AnonymizeSignons();
#endif
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SI_UnanonymizeSignons(){
#ifdef SingleSignon
::SI_UnanonymizeSignons();
#endif
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetProxyHTTP(nsString& aProxyHTTP) {
char *proxy = nsnull;
int32 port;
char outBuf[MAXHOSTNAMELEN + 8];
*outBuf = '\0';
if ( PREF_OK != PREF_CopyCharPref(pref_proxyHttpServer,&proxy) ) {
return NS_FALSE;
}
if ( PREF_OK != PREF_GetIntPref(pref_proxyHttpPort,&port) ) {
PR_FREEIF(proxy);
return NS_FALSE;
}
sprintf(outBuf,"%s:%d", proxy, port);
PR_FREEIF(proxy);
aProxyHTTP.SetString(outBuf);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SetProxyHTTP(nsString& aProxyHTTP) {
nsresult rv = NS_OK;
PRInt32 port;
nsString nsSPort;
char *csPort = nsnull;
char *proxy = nsnull;
nsString nsSProxy;
PRInt32 colonIdx;
PRUnichar colon = ':';
if (aProxyHTTP.Length() < 1) {
NET_SelectProxyStyle(PROXY_STYLE_NONE);
return NS_OK;
}
if ( (colonIdx = aProxyHTTP.Find(colon)) < 0 )
return NS_FALSE;
aProxyHTTP.Left(nsSProxy, colonIdx);
aProxyHTTP.Mid(nsSPort, colonIdx+1, aProxyHTTP.Length() - colonIdx);
proxy = nsSProxy.ToNewCString();
if (!proxy)
return NS_FALSE;
csPort = nsSPort.ToNewCString();
if (!csPort) {
delete proxy;
return NS_FALSE;
}
port = atoi(csPort);
if ( PREF_OK != PREF_SetCharPref(pref_proxyHttpServer, proxy) ) {
rv = NS_FALSE;
}
if ( PREF_OK != PREF_SetIntPref(pref_proxyHttpPort, port) ) {
rv = NS_FALSE;
}
delete proxy;
delete csPort;
NET_SelectProxyStyle(PROXY_STYLE_MANUAL);
return rv;
}
NS_IMETHODIMP
nsNetlibService::GetHTTPOneOne(PRBool& aOneOne) {
aOneOne = (ONE_POINT_ONE == DEFAULT_VERSION);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SetHTTPOneOne(PRBool aSendOneOne) {
if (aSendOneOne)
DEFAULT_VERSION = ONE_POINT_ONE;
else
DEFAULT_VERSION = ONE_POINT_O;
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetAppCodeName(nsString& aAppCodeName)
{
aAppCodeName.SetString(XP_AppCodeName);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetAppVersion(nsString& aAppVersion)
{
aAppVersion.SetString(XP_AppVersion);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetAppName(nsString& aAppName)
{
aAppName.SetString(XP_AppName);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetLanguage(nsString& aLanguage)
{
aLanguage.SetString(XP_AppLanguage);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetPlatform(nsString& aPlatform)
{
aPlatform.SetString(XP_AppPlatform);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetUserAgent(nsString& aUA)
{
char buf[64];
PR_snprintf(buf, 64, "%.100s/%.90s", XP_AppCodeName, XP_AppVersion);
aUA.SetString(buf);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::SetCustomUserAgent(nsString aCustom)
{
PRInt32 inIdx;
PRUnichar junkChar = '['; // damn emacs
PRUnichar inChar = ']';
if (!XP_AppVersion || (0 >= aCustom.Length()) )
return NS_FALSE;
nsString newAppVersion = XP_AppVersion;
inIdx = newAppVersion.Find(inChar);
if (0 > inIdx) {
newAppVersion.Insert(aCustom, inIdx + 1);
}
PR_Free((char *)XP_AppVersion);
XP_AppVersion = newAppVersion.ToNewCString();
return NS_OK;
}
////////////////////////////////////////////////////////////////////////////////
class nsStringHashKey : public nsHashKey
{
public:
nsStringHashKey(const nsString& aName)
: mName(aName)
{
}
virtual ~nsStringHashKey(void)
{
}
virtual PRUint32 HashValue(void) const;
virtual PRBool Equals(const nsHashKey *aKey) const;
virtual nsHashKey *Clone(void) const;
protected:
const nsString& mName;
};
PRUint32 nsStringHashKey::HashValue(void) const
{
return nsCRT::HashValue(mName);
}
PRBool nsStringHashKey::Equals(const nsHashKey *aKey) const
{
const nsStringHashKey* other = (const nsStringHashKey*)aKey;
return mName.EqualsIgnoreCase(other->mName);
}
nsHashKey *nsStringHashKey::Clone(void) const
{
return new nsStringHashKey(mName);
}
struct nsProtocolPair {
nsIProtocolURLFactory* mProtocolURLFactory;
nsIProtocol* mProtocol;
};
NS_IMETHODIMP
nsNetlibService::RegisterProtocol(const nsString& aName,
nsIProtocolURLFactory* aProtocolURLFactory,
nsIProtocol* aProtocol)
{
nsStringHashKey* key = new nsStringHashKey(aName);
if (key == NULL)
return NS_ERROR_OUT_OF_MEMORY;
NS_ADDREF(aProtocolURLFactory);
NS_IF_ADDREF(aProtocol); // XXX remove IF
nsProtocolPair* pair = new nsProtocolPair;
if (pair == NULL) {
delete key;
return NS_ERROR_OUT_OF_MEMORY;
}
pair->mProtocolURLFactory = aProtocolURLFactory;
pair->mProtocol = aProtocol;
void* result = mProtocols->Put(key, pair);
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::UnregisterProtocol(const nsString& aName)
{
nsStringHashKey key(aName);
nsProtocolPair* pair = (nsProtocolPair*)mProtocols->Remove(&key);
NS_RELEASE(pair->mProtocolURLFactory);
NS_IF_RELEASE(pair->mProtocol); // XXX remove IF
delete pair;
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::GetProtocol(const nsString& aName,
nsIProtocolURLFactory* *aProtocolURLFactory,
nsIProtocol* *aProtocol)
{
nsStringHashKey key(aName);
nsProtocolPair* pair = (nsProtocolPair*)mProtocols->Get(&key);
if (pair == NULL)
return NS_ERROR_FAILURE;
if (aProtocolURLFactory)
*aProtocolURLFactory = pair->mProtocolURLFactory;
if (aProtocol)
*aProtocol = pair->mProtocol;
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::CreateURL(nsIURL* *aURL,
const nsString& aSpec,
const nsIURL* aContextURL,
nsISupports* aContainer,
nsIURLGroup* aGroup)
{
nsAutoString protoName;
PRInt32 pos = aSpec.Find(':');
if (pos >= 0) {
aSpec.Left(protoName, pos);
}
else if (aContextURL) {
const char* str;
aContextURL->GetProtocol(&str);
protoName = str;
}
else {
protoName = "http";
}
nsIProtocolURLFactory* protocolURLFactory;
nsresult err = GetProtocol(protoName, &protocolURLFactory, NULL);
if (err != NS_OK) return err;
return protocolURLFactory->CreateURL(aURL, aSpec, aContextURL, aContainer, aGroup);
}
NS_IMETHODIMP nsNetlibService::CreateSocketTransport(nsITransport **aTransport, PRUint32 aPortToUse, const char * aHostName)
{
nsSocketTransport *pNSSocketTransport = NULL;
NS_DEFINE_IID(kITransportIID, NS_ITRANSPORT_IID);
pNSSocketTransport = new nsSocketTransport(aPortToUse, aHostName);
if (pNSSocketTransport->QueryInterface(kITransportIID, (void**)aTransport) != NS_OK) {
// then we're trying get a interface other than nsISupports and
// nsITransport
return NS_ERROR_FAILURE;
}
return NS_OK;
}
NS_IMETHODIMP
nsNetlibService::AreThereActiveConnections()
{
if (NET_AreThereActiveConnections() == PR_TRUE)
return 1;
else
return 0;
}
static NS_DEFINE_IID(kNetServiceCID, NS_NETSERVICE_CID);
NS_NET nsresult NS_NewURL(nsIURL** aInstancePtrResult,
const nsString& aSpec,
const nsIURL* aURL,
nsISupports* aContainer,
nsIURLGroup* aGroup)
{
NS_PRECONDITION(nsnull != aInstancePtrResult, "null ptr");
if (nsnull == aInstancePtrResult) {
return NS_ERROR_NULL_POINTER;
}
nsINetService *inet = nsnull;
nsresult rv = nsServiceManager::GetService(kNetServiceCID,
kINetServiceIID,
(nsISupports **)&inet);
if (rv != NS_OK) return rv;
rv = inet->CreateURL(aInstancePtrResult, aSpec, aURL, aContainer, aGroup);
nsServiceManager::ReleaseService(kNetServiceCID, inet);
return rv;
}
NS_NET nsresult NS_MakeAbsoluteURL(nsIURL* aURL,
const nsString& aBaseURL,
const nsString& aSpec,
nsString& aResult)
{
nsIURL* base = nsnull;
if (0 < aBaseURL.Length()) {
nsresult err = NS_NewURL(&base, aBaseURL);
if (err != NS_OK) return err;
}
else {
const char* str;
aURL->GetSpec(&str);
nsresult err = NS_NewURL(&base, str);
if (err != NS_OK) return err;
}
nsIURL* url = nsnull;
nsresult err = NS_NewURL(&url, aSpec, base);
if (err != NS_OK) goto done;
PRUnichar* str;
err = url->ToString(&str);
if (err) goto done;
aResult = str;
delete []str;
done:
NS_IF_RELEASE(url);
NS_IF_RELEASE(base);
return err;
}
NS_NET nsresult NS_OpenURL(nsIURL* aURL, nsIStreamListener* aConsumer)
{
nsresult rv;
nsIURLGroup* group = nsnull;
rv = aURL->GetURLGroup(&group);
if (NS_SUCCEEDED(rv)) {
if (nsnull != group) {
rv = group->OpenStream(aURL, aConsumer);
NS_RELEASE(group);
} else {
nsINetService *inet = nsnull;
rv = nsServiceManager::GetService(kNetServiceCID,
kINetServiceIID,
(nsISupports **)&inet);
if (NS_SUCCEEDED(rv)) {
rv = inet->OpenStream(aURL, aConsumer);
nsServiceManager::ReleaseService(kNetServiceCID, inet);
}
}
}
return rv;
}
NS_NET nsresult NS_OpenURL(nsIURL* aURL, nsIInputStream* *aNewStream,
nsIStreamListener* aConsumer)
{
nsINetService *inet = nsnull;
nsresult rv = nsServiceManager::GetService(kNetServiceCID,
kINetServiceIID,
(nsISupports **)&inet);
if (rv != NS_OK) return rv;
rv = inet->OpenBlockingStream(aURL, aConsumer, aNewStream);
nsServiceManager::ReleaseService(kNetServiceCID, inet);
return rv;
}
////////////////////////////////////////////////////////////////////////////////
void nsNetlibService::SchedulePollingTimer()
{
#if !defined(NETLIB_THREAD)
// If a timer is already active, then do not create another...
if (nsnull == mPollingTimer) {
if (NS_OK == NS_NewTimer(&mPollingTimer)) {
mPollingTimer->Init(nsNetlibService::NetPollSocketsCallback, this, 1000 / 50);
}
}
#endif /* ! NETLIB_THREAD */
}
void nsNetlibService::CleanupPollingTimer(nsITimer* aTimer)
{
#if !defined(NETLIB_THREAD)
NS_PRECONDITION((aTimer == mPollingTimer), "Unknown Timer...");
NS_RELEASE(mPollingTimer);
#endif /* ! NETLIB_THREAD */
}
#if !defined(NETLIB_THREAD)
void nsNetlibService::NetPollSocketsCallback(nsITimer* aTimer, void* aClosure)
{
nsNetlibService* inet = (nsNetlibService*)aClosure;
NS_PRECONDITION((nsnull != inet), "Null pointer");
if (nsnull != inet) {
(void) NET_PollSockets();
inet->CleanupPollingTimer(aTimer);
// Keep scheduling callbacks as long as there are URLs to process...
/// if (0 < NET_TotalNumberOfProcessingURLs) {
inet->SchedulePollingTimer();
/// }
}
}
#if defined(XP_WIN)
/*
* This routine is used to avoid a (hopefully temporary) problem which netlib
* has when processing blocking HTTP streams.
*
* When ASYNC_DNS is enabled, all DNS lookups go through the main message pump,
* unfortunately, this is not possible when processing a blocking stream, so
* we deadlock :-(
*
* To avoid this deadlock, we synchronously resolve the hostname and store it
* in the little known IPAddressString field of the URL_Struct. This prevents
* netlib from doing an Async DNS lookup later...
*/
nsresult PerformNastyWindowsAsyncDNSHack(URL_Struct *URL_s, nsIURL* aURL)
{
PRHostEnt hpbuf;
char dbbuf[PR_NETDB_BUF_SIZE];
PRStatus err;
nsresult rv = NS_OK;
/* Only attempt to resolve the hostname for HTTP URLs... */
if (0 == PL_strcasecmp("http", aURL->GetProtocol())) {
/* Perform a synchronous DNS lookup... */
err = PR_GetHostByName(aURL->GetHost(), dbbuf, sizeof(dbbuf), &hpbuf);
if (PR_SUCCESS == err) {
int a,b,c,d;
unsigned char *pc;
pc = (unsigned char *) hpbuf.h_addr_list[0];
a = (int) *pc;
b = (int) *(++pc);
c = (int) *(++pc);
d = (int) *(++pc);
URL_s->IPAddressString = PR_smprintf("%d.%d.%d.%d", a,b,c,d);
} else {
/*
* If we fail to resolve a host on a HTTP connection, then
* abort the connection to prevent a deadlock...
*/
rv = NS_ERROR_FAILURE;
}
}
return rv;
}
#endif /* XP_WIN */
#endif /* !NETLIB_THREAD */
// This is global so it can be accessed by the NetFactory (nsNetFactory.cpp)
nsNetlibService *gNetlibService = nsnull;
//
// Class to manage static initialization of the Netlib DLL...
//
struct nsNetlibInit {
nsNetlibInit() {
gNetlibService = nsnull;
#if !defined(NETLIB_THREAD)
/*
* The netlib thread cannot be created within a static constructor
* since a runtime library lock is being held by the mozilla thread
* which results in a deadlock when the netlib thread is started...
*/
(void) NS_InitINetService();
#endif /* !NETLIB_THREAD */
}
~nsNetlibInit() {
#if !defined(NETLIB_THREAD)
NS_ShutdownINetService();
#endif /* !NETLIB_THREAD */
gNetlibService = nsnull;
}
};
#ifdef XP_MAC
static nsNetlibInit* netlibInit = nsnull;
#else
static nsNetlibInit netlibInit;
#endif
extern "C" {
/*
* Factory for creating instance of the NetlibService...
*/
NS_NET nsresult NS_NewINetService(nsINetService** aInstancePtrResult,
nsISupports* aOuter)
{
if (nsnull != aOuter) {
return NS_ERROR_NO_AGGREGATION;
}
#ifdef XP_MAC
// Perform static initialization...
if (nsnull == netlibInit) {
netlibInit = new nsNetlibInit;
}
#endif /* XP_MAC */ // XXX on the mac this never gets shutdown
// The Netlib Service is created by the nsNetlibInit class...
if (nsnull == gNetlibService) {
(void) NS_InitINetService();
/// return NS_ERROR_OUT_OF_MEMORY;
}
return gNetlibService->QueryInterface(kINetServiceIID, (void**)aInstancePtrResult);
}
extern "C" NS_NET nsresult
NS_InitializeHttpURLFactory(nsINetService* inet);
NS_NET nsresult NS_InitINetService()
{
/* XXX: For now only allow a single instance of the Netlib Service */
if (nsnull == gNetlibService) {
gNetlibService = new nsNetlibService();
if (nsnull == gNetlibService) {
return NS_ERROR_OUT_OF_MEMORY;
}
// XXX temporarily, until we have pluggable protocols...
NS_InitializeHttpURLFactory(gNetlibService);
}
NS_ADDREF(gNetlibService);
return NS_OK;
}
NS_NET nsresult NS_ShutdownINetService()
{
return NS_OK;
}
} /* extern "C" */
/*
* This is the generic exit routine for all URLs loaded via the new
* BAM APIs...
*/
static void bam_exit_routine(URL_Struct *URL_s, int status, MWContext *window_id)
{
TRACEMSG(("bam_exit_routine was called...\n"));
if (NULL != URL_s) {
nsConnectionInfo *pConn = (nsConnectionInfo *)URL_s->fe_data;
#ifdef NOISY
printf("+++ Finished loading %s\n", URL_s->address);
#endif
PR_ASSERT(pConn);
/* Release the ConnectionInfo object held in the URL_Struct. */
if (nsnull != pConn) {
/*
* Normally, the stream is closed when the connection has been
* completed. However, if the URL exit proc was called directly
* by NET_GetURL(...), then the stream may still be around...
*/
if (nsnull != pConn->pNetStream) {
pConn->pNetStream->Close();
NS_RELEASE(pConn->pNetStream);
}
/*
* If the connection is still marked as active, then
* notify the Data Consumer that the Binding has completed...
* Since the connection is still active, the stream was never
* closed (or possibly created). So, the binding has failed...
*/
if ((nsConnectionActive == pConn->mStatus) &&
(nsnull != pConn->pConsumer)) {
nsAutoString status;
pConn->pConsumer->OnStopBinding(pConn->pURL, NS_BINDING_FAILED, status);
NS_RELEASE(pConn->pConsumer);
}
/* Release the nsConnectionInfo object hanging off of the fe_data */
URL_s->fe_data = NULL;
NS_RELEASE(pConn);
}
/* Delete the URL_Struct... */
NET_FreeURLStruct(URL_s);
}
}
/*
* Ugly hack to free contexts
*/
extern "C" void net_AddrefContext(MWContext *context)
{
if (nsnull != context) {
context->ref_count++;
}
}
extern "C" void net_ReleaseContext(MWContext *context)
{
if (context) {
NS_PRECONDITION((0 < context->ref_count), "Context reference count is bad.");
if ((0 == --context->ref_count) && (context->modular_data)) {
free_stub_context(context);
} else {
TRACEMSG(("net_ReleaseContext: not releasing non-modular context"));
}
}
}
/*
* Rewrite "resource://" URLs into file: URLs with the path of the
* executable prepended to the file path...
*/
char *mangleResourceIntoFileURL(const char* aResourceFileName)
{
// XXX For now, resources are not in jar files
// Find base path name to the resource file
char* resourceBase;
#ifdef XP_PC
// XXX For now, all resources are relative to the .exe file
resourceBase = (char *)PR_Malloc(_MAX_PATH);;
DWORD mfnLen = GetModuleFileName(g_hInst, resourceBase, _MAX_PATH);
// Truncate the executable name from the rest of the path...
char* cp = strrchr(resourceBase, '\\');
if (nsnull != cp) {
*cp = '\0';
}
// Change the first ':' into a '|'
cp = PL_strchr(resourceBase, ':');
if (nsnull != cp) {
*cp = '|';
}
#endif /* XP_PC */
#ifdef XP_UNIX
//
// Obtain the resource: url base from the environment variable
//
// MOZILLA_HOME
//
// Which is the standard place where mozilla stores global (ie, not
// user specific) data
//
#ifndef MAXPATHLEN
#define MAXPATHLEN 1024 // A good guess, i suppose
#endif
#define MOZILLA_HOME "MOZILLA_HOME"
static char * nsUnixMozillaHomePath = nsnull;
if (nsnull == nsUnixMozillaHomePath)
{
nsUnixMozillaHomePath = PR_GetEnv(MOZILLA_HOME);
}
if (nsnull == nsUnixMozillaHomePath)
{
static char homepath[MAXPATHLEN];
FILE* pp;
if (!(pp = popen("pwd", "r"))) {
#ifdef DEBUG
printf("RESOURCE protocol error in nsURL::mangeResourceIntoFileURL 1\n");
#endif
return(nsnull);
}
if (fgets(homepath, MAXPATHLEN, pp)) {
homepath[PL_strlen(homepath)-1] = 0;
}
else {
#ifdef DEBUG
printf("RESOURCE protocol error in nsURL::mangeResourceIntoFileURL 2\n");
#endif
pclose(pp);
return(nsnull);
}
pclose(pp);
nsUnixMozillaHomePath = homepath;
}
resourceBase = XP_STRDUP(nsUnixMozillaHomePath);
#ifdef DEBUG
printf("Using '%s' as the resource: base\n", resourceBase);
#endif
#endif /* XP_UNIX */
#ifdef XP_MAC
resourceBase = XP_STRDUP("usr/local/netscape/bin");
#endif /* XP_MAC */
// Join base path to resource name
if (aResourceFileName[0] == '/') {
aResourceFileName++;
}
PRInt32 baseLen = PL_strlen(resourceBase);
PRInt32 resLen = PL_strlen(aResourceFileName);
PRInt32 totalLen = 8 + baseLen + 1 + resLen + 1;
char* fileName = (char *)PR_Malloc(totalLen);
PR_snprintf(fileName, totalLen, "file:///%s/%s", resourceBase, aResourceFileName);
#ifdef XP_PC
// Change any backslashes into foreward slashes...
while ((cp = PL_strchr(fileName, '\\')) != 0) {
*cp = '/';
cp++;
}
#endif /* XP_PC */
PR_Free(resourceBase);
return fileName;
}
#ifdef XP_PC
BOOL WINAPI DllMain(HINSTANCE hDllInst,
DWORD fdwReason,
LPVOID lpvReserved)
{
BOOL bResult = TRUE;
switch (fdwReason)
{
case DLL_PROCESS_ATTACH:
{
// save our instance
g_hInst = hDllInst;
}
break;
case DLL_PROCESS_DETACH:
break;
case DLL_THREAD_ATTACH:
break;
case DLL_THREAD_DETACH:
break;
default:
break;
}
return (bResult);
}
#endif /* XP_PC */
Reference in New Issue View Git Blame Copy Permalink