/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- * * The contents of this file are subject to the Netscape Public * License Version 1.1 (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. * * Contributor(s): */ #include "nsSilentDownload.h" #include "nsSilentDownloadPrivate.h" #include "nscore.h" #include "nsIFactory.h" #include "nsISupports.h" #include "nsIComponentManager.h" #include "nsIScriptObjectOwner.h" #include "nsIScriptGlobalObject.h" #include "nsString.h" #include "nsSpecialSystemDirectory.h" #include "pratom.h" #include "prmem.h" #include "prio.h" #include "mkutils.h" #include "prefapi.h" #include "nsIURL.h" #include "nsIIOService.h" static NS_DEFINE_CID(kIOServiceCID, NS_IOSERVICE_CID); #include "nsINetlibURL.h" #include "nsINetService.h" #include "nsIInputStream.h" #include "nsIStreamListener.h" #include "nsIDOMSilentDownload.h" #include "nsIDOMSilentDownloadTask.h" /* For Javascript Namespace Access */ #include "nsDOMCID.h" #include "nsIServiceManager.h" #include "nsINameSpaceManager.h" #include "nsIScriptNameSetRegistry.h" #include "nsIScriptNameSpaceManager.h" #include "nsIScriptExternalNameSet.h" #include "nsITimer.h" #include "nsITimerCallback.h" #include "nsIBrowserWindow.h" #include "nsIWebShell.h" #include "nsIServiceManager.h" #include "nsCOMPtr.h" static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID); static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID); static NS_DEFINE_CID(kComponentManagerCID, NS_COMPONENTMANAGER_CID); static NS_DEFINE_IID(kIScriptObjectOwnerIID, NS_ISCRIPTOBJECTOWNER_IID); static NS_DEFINE_IID(kIScriptNameSetRegistryIID, NS_ISCRIPTNAMESETREGISTRY_IID); static NS_DEFINE_IID(kCScriptNameSetRegistryCID, NS_SCRIPT_NAMESET_REGISTRY_CID); static NS_DEFINE_IID(kIScriptExternalNameSetIID, NS_ISCRIPTEXTERNALNAMESET_IID); static NS_DEFINE_IID(kInetServiceIID, NS_INETSERVICE_IID); static NS_DEFINE_IID(kInetServiceCID, NS_NETSERVICE_CID); static NS_DEFINE_IID(kInetLibURLIID, NS_INETLIBURL_IID); static NS_DEFINE_IID(kIStreamListenerIID, NS_ISTREAMLISTENER_IID); static NS_DEFINE_IID(kBrowserWindowCID, NS_BROWSER_WINDOW_CID); static NS_DEFINE_IID(kIBrowserWindowIID, NS_IBROWSER_WINDOW_IID); static NS_DEFINE_IID(kISilentDownloadTaskIID, NS_IDOMSILENTDOWNLOADTASK_IID); static NS_DEFINE_IID(kISilentDownloadIID, NS_IDOMSILENTDOWNLOAD_IID); static NS_DEFINE_IID(kSilentDownloadCID, NS_SilentDownload_CID); static NS_DEFINE_IID(kSilentDownloadTaskCID, NS_SilentDownloadTask_CID); static NS_DEFINE_IID(kSilentDownloadFactoryCID, NS_SilentDownloadFactory_CID); static NS_DEFINE_IID(kSilentDownloadTaskFactoryCID, NS_SilentDownloadTaskFactory_CID); static PRInt32 gLockCnt = 0; static PRInt32 gInstanceCnt = 0; static nsITimer *gTaskTimer = nsnull; static nsINetService *gInetService = nsnull; static SDL_TaskList *gTasks = nsnull; static SDL_TaskList *gNextReadyTask = nsnull; static PRInt32 gByteRange = 0; static PRInt32 gInterval = 0xFFFF; ///////////////////////////////////////////////////////////////////////// // static helper meathods ///////////////////////////////////////////////////////////////////////// static void GetSilentDownloadDirectory(char* directory) { if (PREF_OK != PREF_CopyCharPref("SilentDownload.directory", (char**)directory)) { directory = NULL; } } static void GetSilentDownloadDefaults(PRBool* enabled, PRInt32 *bytes_range, PRInt32 *interval) { *enabled = PR_FALSE; *bytes_range = 0; *interval = 0; PREF_GetBoolPref( "SilentDownload.enabled", enabled); //fix if (*enabled == PR_FALSE) // return; if (PREF_OK != PREF_GetIntPref("SilentDownload.range", bytes_range)) { *bytes_range = 3000; } if (PREF_OK != PREF_GetIntPref("SilentDownload.interval", interval)) { *interval = 10000; } } nsFileSpec * CreateOutFileLocation(const nsString& url, const nsString& directory) { nsSpecialSystemDirectory outFileLocation(nsSpecialSystemDirectory::OS_CurrentProcessDirectory); PRInt32 result = url.RFindChar('/'); if (result != -1) { nsString fileName; url.Right(fileName, (url.Length() - result) ); outFileLocation += fileName; } else { outFileLocation += "sdl"; } outFileLocation.MakeUnique(); return new nsSpecialSystemDirectory(outFileLocation); } ///////////////////////////////////////////////////////////////////////// // nsSilentDownloadManager ///////////////////////////////////////////////////////////////////////// nsSilentDownloadManager* nsSilentDownloadManager::mInstance = NULL; nsSilentDownloadManager::nsSilentDownloadManager() { mScriptObject = nsnull; PR_AtomicIncrement(&gInstanceCnt); NS_INIT_REFCNT(); Startup(); } nsSilentDownloadManager::~nsSilentDownloadManager() { PR_AtomicDecrement(&gInstanceCnt); Shutdown(); } nsSilentDownloadManager * nsSilentDownloadManager::GetInstance() { if (mInstance == NULL) { mInstance = new nsSilentDownloadManager(); } return mInstance; } nsresult nsSilentDownloadManager::LoadAllTasks(void) { gNextReadyTask = gTasks; return NS_OK; } nsresult nsSilentDownloadManager::StoreAllTasks(void) { return NS_OK; } NS_IMPL_ADDREF(nsSilentDownloadManager) NS_IMPL_RELEASE(nsSilentDownloadManager) NS_IMETHODIMP nsSilentDownloadManager::QueryInterface(REFNSIID aIID,void** aInstancePtr) { if (aInstancePtr == NULL) { return NS_ERROR_NULL_POINTER; } // Always NULL result, in case of failure *aInstancePtr = NULL; if ( aIID.Equals(kISilentDownloadIID) ) { nsIDOMSilentDownload* tmp = this; *aInstancePtr = (void*)tmp; AddRef(); return NS_OK; } else if ( aIID.Equals(kIScriptObjectOwnerIID)) { nsIScriptObjectOwner* tmp = this; *aInstancePtr = (void*)tmp; AddRef(); return NS_OK; } else if ( aIID.Equals(kISupportsIID) ) { nsIDOMSilentDownload* tmp1 = this; nsISupports* tmp2 = tmp1; *aInstancePtr = (void*)tmp2; AddRef(); return NS_OK; } return NS_NOINTERFACE; } NS_IMETHODIMP nsSilentDownloadManager::GetScriptObject(nsIScriptContext *aContext, void** aScriptObject) { nsresult res = NS_OK; if (nsnull == mScriptObject) { nsIScriptGlobalObject *global = aContext->GetGlobalObject(); res = NS_NewScriptSilentDownload(aContext, (nsISupports *)(nsIDOMSilentDownload*)this, global, (void**)&mScriptObject); NS_IF_RELEASE(global); } *aScriptObject = mScriptObject; return res; } NS_IMETHODIMP nsSilentDownloadManager::SetScriptObject(void *aScriptObject) { mScriptObject = aScriptObject; return NS_OK; } void nsSilentDownloadManager::Notify(nsITimer * aTimer) { /* Fix: maybe some additional check on gNextReadyTask */ if (gTasks != NULL && gNextReadyTask != NULL) { if (! gInetService->AreThereActiveConnections() ) { gNextReadyTask->task->DownloadSelf(gByteRange); if (gNextReadyTask->next == NULL) { gNextReadyTask = gTasks; } else { gNextReadyTask = gNextReadyTask->next; } } } NS_RELEASE(gTaskTimer); if (NS_OK == NS_NewTimer(&gTaskTimer)) gTaskTimer->Init(this, gInterval); } NS_IMETHODIMP nsSilentDownloadManager::Startup() { PRBool enabled = PR_FALSE; GetSilentDownloadDefaults(&enabled, &gByteRange, &gInterval); //if (enabled == PR_FALSE) // FIX ignore for now: return -1; /***************************************/ /* Add us to the Javascript Name Space */ /***************************************/ nsIScriptNameSetRegistry *registry; nsresult result = nsServiceManager::GetService(kCScriptNameSetRegistryCID, kIScriptNameSetRegistryIID, (nsISupports **)®istry); if (NS_OK == result) { nsSilentDownloadNameSet* nameSet = new nsSilentDownloadNameSet(); registry->AddExternalNameSet(nameSet); /* FIX - do we need to release this service? When we do, it get deleted,and our name is lost. */ } /************************************************************************/ /* Create an instance of INet so that we can see if the network is busy */ /************************************************************************/ result = nsComponentManager::CreateInstance(kInetServiceCID, nsnull, kInetServiceIID, (void**)&gInetService); if (result != NS_OK) return result; /************************/ /* Load all saved tasks */ /************************/ result = LoadAllTasks(); if (result != NS_OK) return result; /************************/ /* Start Timer */ /************************/ if (NS_OK == NS_NewTimer(&gTaskTimer)) gTaskTimer->Init(this, gInterval); return result; } NS_IMETHODIMP nsSilentDownloadManager::Shutdown() { StoreAllTasks(); return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::Add(nsIDOMSilentDownloadTask* aTask) { if (aTask == NULL) return NS_ERROR_FAILURE; /* Check to see if we already have this task in our list */ SDL_TaskList *node = gTasks; nsString nodeIDString; nsString addIDString; aTask->GetId(addIDString); while (node != NULL) { node->task->GetId(nodeIDString); if (nodeIDString == addIDString) { /*we already have this ID in our list, ignore */ return NS_OK; } node = node->next; } /* add the task to our list */ SDL_TaskList* taskNode = (SDL_TaskList*)PR_MALLOC(sizeof(SDL_TaskList)); aTask->AddRef(); taskNode->next = gTasks; taskNode->task = aTask; gTasks = taskNode; /* Lets set the next task to run to this one */ gNextReadyTask = taskNode; aTask->SetState(nsIDOMSilentDownloadTask::SDL_STARTED); return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::Remove(nsIDOMSilentDownloadTask* aTask) { if (aTask == NULL) return NS_ERROR_FAILURE; /* Remove from our list */ SDL_TaskList *node = gTasks; SDL_TaskList *lastnode = gTasks; nsString nodeIDString; nsString doomedIDString; aTask->GetId(doomedIDString); while (node != NULL) { node->task->GetId(nodeIDString); if (nodeIDString == doomedIDString) { /* we want to delete this node */ if (node == gTasks) { gTasks = node->next; } else { lastnode->next = node->next; } node->task->Release(); PR_DELETE(node); break; } lastnode = node; node = node->next; } return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::Find(const nsString& aId, nsIDOMSilentDownloadTask** aReturn) { *aReturn=nsnull; SDL_TaskList *node = gTasks; nsString nodeIDString; while (node != NULL) { node->task->GetId(nodeIDString); if (nodeIDString == aId) { *aReturn = node->task; node->task->AddRef(); break; } node = node->next; } return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::GetByteRange(PRInt32* aByterange) { *aByterange = gByteRange; return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::SetByteRange(PRInt32 aByterange) { gByteRange = aByterange; return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::GetInterval(PRInt32* aInterval) { *aInterval = gInterval; return NS_OK; } NS_IMETHODIMP nsSilentDownloadManager::SetInterval(PRInt32 aInterval) { gInterval = aInterval; return NS_OK; } ///////////////////////////////////////////////////////////////////////// // nsSilentDownloadTask ///////////////////////////////////////////////////////////////////////// nsSilentDownloadTask::nsSilentDownloadTask() { mScriptObject = nsnull; mListener = nsnull; mWindow = nsnull; mWebShell = nsnull; mState = nsIDOMSilentDownloadTask::SDL_NOT_INITED; mNextByte = 0; mOutFile = nsnull; PR_AtomicIncrement(&gInstanceCnt); NS_INIT_REFCNT(); } nsSilentDownloadTask::~nsSilentDownloadTask() { if (mOutFile) delete mOutFile; mListener->Release(); PR_AtomicDecrement(&gInstanceCnt); } void nsSilentDownloadTask::LoadScript(void) { if (mState == nsIDOMSilentDownloadTask::SDL_NOT_ADDED || mState == nsIDOMSilentDownloadTask::SDL_NOT_INITED ) return; if (mWindow == nsnull) { nsresult rv = nsComponentManager::CreateInstance(kBrowserWindowCID, nsnull, kIBrowserWindowIID, (void**) &mWindow); if (rv == NS_OK) { nsRect rect(0, 0, 275, 300); rv = mWindow->Init(nsnull, nsnull, rect, PRUint32(0), PR_FALSE); if (rv == NS_OK) { rv = mWindow->GetWebShell(mWebShell); mWebShell->LoadURL(mScript.GetUnicode()); } else { mWindow->Release(); mWindow=nsnull; mState = nsIDOMSilentDownloadTask::SDL_ERROR; SetErrorMsg("Couldn't Open Window"); } } } else { if (mWebShell) { mWebShell->LoadURL(mScript.GetUnicode()); } else { mState = nsIDOMSilentDownloadTask::SDL_ERROR; SetErrorMsg("Couldn't Open Window"); } } } NS_IMPL_ADDREF(nsSilentDownloadTask) NS_IMPL_RELEASE(nsSilentDownloadTask) NS_IMETHODIMP nsSilentDownloadTask::QueryInterface(REFNSIID aIID,void** aInstancePtr) { if (aInstancePtr == NULL) { return NS_ERROR_NULL_POINTER; } // Always NULL result, in case of failure *aInstancePtr = NULL; if ( aIID.Equals(kIScriptObjectOwnerIID)) { *aInstancePtr = (void*) ((nsIScriptObjectOwner*)this); AddRef(); return NS_OK; } else if ( aIID.Equals(kISilentDownloadTaskIID) ) { *aInstancePtr = (void*) ((nsIDOMSilentDownloadTask*)this); AddRef(); return NS_OK; } else if ( aIID.Equals(kISupportsIID) ) { *aInstancePtr = (void*)(nsISupports*)(nsIScriptObjectOwner*)this; AddRef(); return NS_OK; } return NS_NOINTERFACE; } NS_IMETHODIMP nsSilentDownloadTask::GetScriptObject(nsIScriptContext *aContext, void** aScriptObject) { NS_PRECONDITION(nsnull != aScriptObject, "null arg"); nsresult res = NS_OK; if (nsnull == mScriptObject) { res = NS_NewScriptSilentDownloadTask( aContext, (nsISupports *)(nsIDOMSilentDownloadTask*)this, nsnull, &mScriptObject); } *aScriptObject = mScriptObject; return res; } NS_IMETHODIMP nsSilentDownloadTask::SetScriptObject(void *aScriptObject) { mScriptObject = aScriptObject; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::Init(const nsString& aId, const nsString& aUrl, const nsString& aScript) { char *defaultDirectoryCString = NULL; nsFileSpec *outFile = NULL; GetSilentDownloadDirectory(defaultDirectoryCString); mId = aId; mUrl = aUrl; mScript = aScript; //Fix use silentdownload directory mOutFile = CreateOutFileLocation(aUrl, nsString("/SilentDL")); // FIx need to delete defaultDirectoryCString if (mOutFile == NULL) { SetState(nsIDOMSilentDownloadTask::SDL_ERROR); SetErrorMsg("Couldn't access destination directory to save file"); return -1; } mNextByte = mOutFile->GetFileSize(); if (mNextByte < 0) { SetState(nsIDOMSilentDownloadTask::SDL_ERROR); SetErrorMsg("Negative Byte!"); return NS_OK; } /* Everything looks good. Mark as SDL_NOT_ADDED. */ mState = nsIDOMSilentDownloadTask::SDL_NOT_ADDED; mListener = new nsSilentDownloadListener(); mListener->SetSilentDownloadInfo(this); nsSilentDownloadManager* sdm = nsSilentDownloadManager::GetInstance(); sdm->Add(this); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetId(nsString& aId) { aId = mId; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetUrl(nsString& aUrl) { aUrl = mUrl; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetScript(nsString& aScript) { aScript = mScript; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetState(PRInt32* aState) { *aState = mState; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::SetState(PRInt32 aState) { /* This function is so that our listener can change the state. I would rather not expose this to Javascript if possible*/ mState = aState; LoadScript(); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetErrorMsg(nsString& aErrorMsg) { /* This function is so that our listener can change the state. I would rather not expose this to Javascript if possible*/ aErrorMsg = mErrorMsg; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::SetErrorMsg(const nsString& aErrorMsg) { mErrorMsg = aErrorMsg; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetNextByte(PRInt32* aNext_byte) { *aNext_byte = mNextByte; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::SetNextByte(PRInt32 aNextByte) { mNextByte = aNextByte; return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::GetOutFile(nsString& aOutFile) { aOutFile.SetString(nsNSPRPath(*mOutFile)); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::Remove() { mState = nsIDOMSilentDownloadTask::SDL_NOT_ADDED; mWebShell->Release(); mWindow->Close(); mWindow->Release(); mWindow = nsnull; nsSilentDownloadManager* sdm = nsSilentDownloadManager::GetInstance(); sdm->Remove(this); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::Suspend() { SetState(nsIDOMSilentDownloadTask::SDL_SUSPENDED); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::Resume() { SetState(nsIDOMSilentDownloadTask::SDL_STARTED); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::DownloadNow() { SetState(nsIDOMSilentDownloadTask::SDL_DOWNLOADING_NOW); DownloadSelf(0); return NS_OK; } NS_IMETHODIMP nsSilentDownloadTask::DownloadSelf(PRInt32 range) { long result=0; char* byteRangeString=NULL; nsIURI *pURL; nsILoadAttribs *loadAttr; if (mState != nsIDOMSilentDownloadTask::SDL_STARTED && mState != nsIDOMSilentDownloadTask::SDL_DOWNLOADING_NOW) { /* We do not have to do a download here. */ return 0; } // Create the URL object... pURL = NULL; NS_WITH_SERVICE(nsIIOService, service, kIOServiceCID, &result); if (NS_FAILED(result)) return result; nsIURI *uri = nsnull; char *uriStr = mUrl.ToNewCString(); if (!uriStr) return NS_ERROR_OUT_OF_MEMORY; result = service->NewURI(uriStr, nsnull, &uri); nsCRT::free(uriStr); if (NS_FAILED(result)) return result; result = uri->QueryInterface(nsIURI::GetIID(), (void**)&pURL); NS_RELEASE(uri); if (result != NS_OK) { SetState(nsIDOMSilentDownloadTask::SDL_ERROR); SetErrorMsg("Couldn't set up download. Out of memory"); return -1; } pURL->GetLoadAttribs(&loadAttr); loadAttr->SetLoadType(nsURLLoadBackground); if (mState != nsIDOMSilentDownloadTask::SDL_DOWNLOADING_NOW) { /* Do Byte Range Stuff */ byteRangeString = PR_sprintf_append( byteRangeString, "bytes=%ld-%ld", mNextByte, mNextByte+range); loadAttr->SetByteRangeHeader(byteRangeString); PR_FREEIF(byteRangeString); } result = NS_OpenURL(pURL, mListener); /* If the open failed... */ if (NS_OK != result) { } return result; } ///////////////////////////////////////////////////////////////////////// // nsSilentDownloadImplFactory ///////////////////////////////////////////////////////////////////////// nsSilentDownloadManagerFactory::nsSilentDownloadManagerFactory(void) { mRefCnt=0; PR_AtomicIncrement(&gInstanceCnt); } nsSilentDownloadManagerFactory::~nsSilentDownloadManagerFactory(void) { PR_AtomicDecrement(&gInstanceCnt); } NS_IMPL_ISUPPORTS(nsSilentDownloadManagerFactory,kIFactoryIID) NS_IMETHODIMP nsSilentDownloadManagerFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult) { if (aResult == NULL) { return NS_ERROR_NULL_POINTER; } *aResult = NULL; nsSilentDownloadManager *inst = nsSilentDownloadManager::GetInstance(); if (inst == NULL) return NS_ERROR_OUT_OF_MEMORY; nsresult result = inst->QueryInterface(aIID, aResult); if (NS_FAILED(result)) { *aResult = NULL; } NS_ADDREF(inst); // Are we sure that we need to addref??? return result; } NS_IMETHODIMP nsSilentDownloadManagerFactory::LockFactory(PRBool aLock) { if (aLock) PR_AtomicIncrement(&gLockCnt); else PR_AtomicDecrement(&gLockCnt); return NS_OK; } ///////////////////////////////////////////////////////////////////////// // nsSilentDownloadTaskFactory ///////////////////////////////////////////////////////////////////////// nsSilentDownloadTaskFactory::nsSilentDownloadTaskFactory(void) { mRefCnt=0; PR_AtomicIncrement(&gInstanceCnt); } nsSilentDownloadTaskFactory::~nsSilentDownloadTaskFactory(void) { PR_AtomicDecrement(&gInstanceCnt); } NS_IMPL_ISUPPORTS(nsSilentDownloadTaskFactory,kIFactoryIID) NS_IMETHODIMP nsSilentDownloadTaskFactory::CreateInstance(nsISupports *aOuter, REFNSIID aIID, void **aResult) { if (aResult == NULL) { return NS_ERROR_NULL_POINTER; } *aResult = NULL; /* do I have to use iSupports? */ nsSilentDownloadTask *inst = new nsSilentDownloadTask(); if (inst == NULL) return NS_ERROR_OUT_OF_MEMORY; nsresult result = inst->QueryInterface(aIID, aResult); if (result != NS_OK) delete inst; return result; } NS_IMETHODIMP nsSilentDownloadTaskFactory::LockFactory(PRBool aLock) { if (aLock) PR_AtomicIncrement(&gLockCnt); else PR_AtomicDecrement(&gLockCnt); return NS_OK; } //////////////////////////////////////////////////////////////////////////////// // nsSilentDownloadNameSet //////////////////////////////////////////////////////////////////////////////// nsSilentDownloadNameSet::nsSilentDownloadNameSet() { NS_INIT_REFCNT(); } nsSilentDownloadNameSet::~nsSilentDownloadNameSet() { } NS_IMPL_ISUPPORTS(nsSilentDownloadNameSet, kIScriptExternalNameSetIID); NS_IMETHODIMP nsSilentDownloadNameSet::InitializeClasses(nsIScriptContext* aScriptContext) { nsresult result = NS_OK; result = NS_InitSilentDownloadClass(aScriptContext, nsnull); if (NS_OK != result) return result; result = NS_InitSilentDownloadTaskClass(aScriptContext, nsnull); return result; } NS_IMETHODIMP nsSilentDownloadNameSet::AddNameSet(nsIScriptContext* aScriptContext) { nsresult result = NS_OK; nsIScriptNameSpaceManager* manager; result = aScriptContext->GetNameSpaceManager(&manager); if (NS_OK == result) { result = manager->RegisterGlobalName("SilentDownloadTask", kSilentDownloadTaskCID, PR_TRUE); if (NS_OK != result) return result; result = manager->RegisterGlobalName("SilentDownloadManager", kSilentDownloadCID, PR_FALSE); NS_RELEASE(manager); } return result; } //////////////////////////////////////////////////////////////////////////////// // nsSilentDownloadListener //////////////////////////////////////////////////////////////////////////////// nsSilentDownloadListener::nsSilentDownloadListener() { NS_INIT_REFCNT(); } nsSilentDownloadListener::~nsSilentDownloadListener() { mSilentDownloadTask->Release(); if (mOutFileDesc != NULL) PR_Close(mOutFileDesc); } NS_IMPL_ISUPPORTS( nsSilentDownloadListener, kIStreamListenerIID ) NS_IMETHODIMP nsSilentDownloadListener::GetBindInfo(nsIURI* aURL, nsStreamBindingInfo* info) { return NS_OK; } NS_IMETHODIMP nsSilentDownloadListener::OnProgress( nsIURI* aURL, PRUint32 Progress, PRUint32 ProgressMax) { return NS_OK; } NS_IMETHODIMP nsSilentDownloadListener::OnStatus(nsIURI* aURL, const PRUnichar* aMsg) { return NS_OK; } NS_IMETHODIMP nsSilentDownloadListener::OnStartRequest(nsIURI* aURL, const char *aContentType) { return NS_OK; } NS_IMETHODIMP nsSilentDownloadListener::OnStopRequest(nsIURI* aURL, nsresult status, const PRUnichar* aMsg) { nsresult result = NS_OK; PRInt32 content_length = 0; PRInt32 server_status = 0; PRInt32 nextByte; switch( status ) { case NS_BINDING_SUCCEEDED: /* What we are going to is check to see if our nextByte that the task will get is passed the content_length of the URL. What happens if there is no content_length? */ aURL->GetServerStatus(&server_status); if (server_status == 404) { mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR); mSilentDownloadTask->SetErrorMsg("Server Error 400."); return NS_OK; } else if (server_status == 500) { mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR); mSilentDownloadTask->SetErrorMsg("Server Error 500."); return NS_OK; } aURL->GetContentLength(&content_length); mSilentDownloadTask->GetNextByte(&nextByte); if (content_length <= nextByte || content_length == 0) { mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_COMPLETED); PR_Close(mOutFileDesc); mOutFileDesc=NULL; } break; case NS_BINDING_FAILED: case NS_BINDING_ABORTED: mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR); mSilentDownloadTask->SetErrorMsg("Could Not Download."); break; default: result = NS_ERROR_ILLEGAL_VALUE; } return result; } NS_IMETHODIMP nsSilentDownloadListener::OnDataAvailable(nsIURI* aURL, nsIInputStream *pIStream, PRUint32 length) { PRUint32 len; PRInt32 nextByte; PRInt32 byteCountDown = length; nsresult err; char buffer[4096]; do { err = pIStream->Read(buffer, 4096, &len); byteCountDown -= len; if (err == NS_OK) { mSilentDownloadTask->GetNextByte(&nextByte); if ( PR_Seek(mOutFileDesc, nextByte, PR_SEEK_SET) == -1 ) { /* Error */ mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR); mSilentDownloadTask->SetErrorMsg("File Seek Error."); return -1; } if( PR_Write(mOutFileDesc, buffer, len) == -1 ) { /* Error */ mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR); mSilentDownloadTask->SetErrorMsg("File Write Error."); return -1; } mSilentDownloadTask->SetNextByte(nextByte+len); } } while (len > 0 && byteCountDown > 0); return 0; } NS_IMETHODIMP nsSilentDownloadListener::SetSilentDownloadInfo(nsIDOMSilentDownloadTask* con) { nsString aFile; mSilentDownloadTask = con; con->AddRef(); mSilentDownloadTask->GetOutFile(aFile); mOutFileDesc = PR_Open(nsAutoCString(aFile), PR_CREATE_FILE | PR_RDWR, 0644); if(mOutFileDesc == NULL) { mSilentDownloadTask->SetState(nsIDOMSilentDownloadTask::SDL_ERROR); mSilentDownloadTask->SetErrorMsg("Could not create OUT file."); return NS_OK; }; return NS_OK; } //////////////////////////////////////////////////////////////////////////////// // DLL Entry Points: //////////////////////////////////////////////////////////////////////////////// extern "C" NS_EXPORT PRBool NSCanUnload(nsISupports* aServMgr) { return PRBool (gInstanceCnt == 0 && gLockCnt == 0); } extern "C" NS_EXPORT nsresult NSRegisterSelf(nsISupports* aServMgr, const char *path) { nsresult rv; nsCOMPtr servMgr(do_QueryInterface(aServMgr, &rv)); if (NS_FAILED(rv)) return rv; nsIComponentManager* compMgr; rv = servMgr->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), (nsISupports**)&compMgr); if (NS_FAILED(rv)) return rv; #ifdef NS_DEBUG printf("*** SilentDownload is being registered\n"); #endif rv = compMgr->RegisterComponent(kSilentDownloadCID, NULL, NULL, path, PR_TRUE, PR_TRUE); if (NS_FAILED(rv)) goto done; rv = compMgr->RegisterComponent(kSilentDownloadTaskCID, NULL, NULL, path, PR_TRUE, PR_TRUE); done: (void)servMgr->ReleaseService(kComponentManagerCID, compMgr); return rv; } extern "C" NS_EXPORT nsresult NSUnregisterSelf(nsISupports* aServMgr, const char *path) { nsresult rv; nsCOMPtr servMgr(do_QueryInterface(aServMgr, &rv)); if (NS_FAILED(rv)) return rv; nsIComponentManager* compMgr; rv = servMgr->GetService(kComponentManagerCID, nsIComponentManager::GetIID(), (nsISupports**)&compMgr); if (NS_FAILED(rv)) return rv; #ifdef NS_DEBUG printf("*** SilentDownload is being unregistered\n"); #endif rv = compMgr->UnregisterComponent(kSilentDownloadCID, path); if (NS_FAILED(rv)) goto done; rv = compMgr->UnregisterComponent(kSilentDownloadTaskCID, path); done: (void)servMgr->ReleaseService(kComponentManagerCID, compMgr); return rv; } extern "C" NS_EXPORT nsresult NSGetFactory(nsISupports* aServMgr, const nsCID &aClass, const char *aClassName, const char *aProgID, nsIFactory **aFactory) { if (aFactory == NULL) { return NS_ERROR_NULL_POINTER; } *aFactory = NULL; nsISupports *inst; if ( aClass.Equals(kSilentDownloadCID) ) { inst = new nsSilentDownloadManagerFactory(); } else if ( aClass.Equals(kSilentDownloadTaskCID) ) { inst = new nsSilentDownloadTaskFactory(); } else { return NS_ERROR_ILLEGAL_VALUE; } if (inst == NULL) { return NS_ERROR_OUT_OF_MEMORY; } nsresult res = inst->QueryInterface(kIFactoryIID, (void**) aFactory); if (res != NS_OK) { delete inst; } return res; }