2505 lines
60 KiB
C++
2505 lines
60 KiB
C++
/* -*- 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 "NPL"); you may not use this file except in
|
|
* compliance with the NPL. You may obtain a copy of the NPL at
|
|
* http://www.mozilla.org/NPL/
|
|
*
|
|
* Software distributed under the NPL is distributed on an "AS IS" basis,
|
|
* WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
|
|
* for the specific language governing rights and limitations under the
|
|
* NPL.
|
|
*
|
|
* The Initial Developer of this code under the NPL is Netscape
|
|
* Communications Corporation. Portions created by Netscape are
|
|
* Copyright (C) 1998 Netscape Communications Corporation. All Rights
|
|
* Reserved.
|
|
*/
|
|
|
|
#include "nsPluginHostImpl.h"
|
|
#include <stdio.h>
|
|
#include "prio.h"
|
|
#include "prmem.h"
|
|
#include "ns4xPlugin.h"
|
|
#include "nsPluginInstancePeer.h"
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
#include "nsIPluginStreamListener.h"
|
|
#else
|
|
#include "nsPluginStreamPeer.h"
|
|
#endif
|
|
|
|
#include "nsIStreamListener.h"
|
|
#include "nsIURL.h"
|
|
#include "nsIInputStream.h"
|
|
#include "nsINetService.h"
|
|
#include "nsIServiceManager.h"
|
|
#include "prprf.h"
|
|
#include "gui.h"
|
|
|
|
#ifdef USE_CACHE
|
|
#include "nsCacheManager.h"
|
|
#include "nsDiskModule.h"
|
|
#endif
|
|
|
|
#ifdef XP_PC
|
|
#include "windows.h"
|
|
#include "winbase.h"
|
|
#endif
|
|
|
|
#include "nsFileSpec.h"
|
|
|
|
#ifdef XP_MAC
|
|
#include "nsPluginsDir.h"
|
|
#endif
|
|
|
|
//uncomment this to use netlib to determine what the
|
|
//user agent string is. we really *want* to do this,
|
|
//can't today since netlib returns 4.05, but this
|
|
//version of plugin functionality really supports
|
|
//5.0 level features. once netlib is returning
|
|
//5.0x, then we can turn this on again. MMP
|
|
//#define USE_NETLIB_FOR_USER_AGENT
|
|
|
|
static NS_DEFINE_IID(kIPluginInstanceIID, NS_IPLUGININSTANCE_IID);
|
|
static NS_DEFINE_IID(kIPluginInstancePeerIID, NS_IPLUGININSTANCEPEER_IID);
|
|
static NS_DEFINE_IID(kIPluginManagerIID, NS_IPLUGINMANAGER_IID);
|
|
static NS_DEFINE_IID(kIPluginManager2IID, NS_IPLUGINMANAGER2_IID);
|
|
static NS_DEFINE_IID(kIPluginHostIID, NS_IPLUGINHOST_IID);
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
static NS_DEFINE_IID(kIPluginStreamInfoIID, NS_IPLUGINSTREAMINFO_IID);
|
|
#else
|
|
static NS_DEFINE_IID(kIPluginStreamPeerIID, NS_IPLUGINSTREAMPEER_IID);
|
|
#endif
|
|
static NS_DEFINE_CID(kPluginCID, NS_PLUGIN_CID);
|
|
static NS_DEFINE_IID(kIFactoryIID, NS_IFACTORY_IID);
|
|
static NS_DEFINE_IID(kISupportsIID, NS_ISUPPORTS_IID);
|
|
static NS_DEFINE_IID(kIStreamListenerIID, NS_ISTREAMLISTENER_IID);
|
|
static NS_DEFINE_IID(kIStreamObserverIID, NS_ISTREAMOBSERVER_IID);
|
|
static NS_DEFINE_IID(kINetServiceIID, NS_INETSERVICE_IID);
|
|
static NS_DEFINE_IID(kNetServiceCID, NS_NETSERVICE_CID);
|
|
static NS_DEFINE_IID(kIFileUtilitiesIID, NS_IFILEUTILITIES_IID);
|
|
|
|
nsPluginTag :: nsPluginTag()
|
|
{
|
|
mNext = nsnull;
|
|
mName = nsnull;
|
|
mDescription = nsnull;
|
|
mMimeType = nsnull;
|
|
mMimeDescription = nsnull;
|
|
mExtensions = nsnull;
|
|
mVariants = 0;
|
|
mMimeTypeArray = nsnull;
|
|
mMimeDescriptionArray = nsnull;
|
|
mExtensionsArray = nsnull;
|
|
mLibrary = nsnull;
|
|
mEntryPoint = nsnull;
|
|
mFlags = NS_PLUGIN_FLAG_ENABLED;
|
|
}
|
|
|
|
nsPluginTag :: ~nsPluginTag()
|
|
{
|
|
NS_IF_RELEASE(mEntryPoint);
|
|
|
|
if (nsnull != mName)
|
|
{
|
|
PR_Free(mName);
|
|
mName = nsnull;
|
|
}
|
|
|
|
if (nsnull != mDescription)
|
|
{
|
|
PR_Free(mDescription);
|
|
mDescription = nsnull;
|
|
}
|
|
|
|
if (nsnull != mMimeType)
|
|
{
|
|
PR_Free(mMimeType);
|
|
mMimeType = nsnull;
|
|
}
|
|
|
|
if (nsnull != mMimeDescription)
|
|
{
|
|
PR_Free(mMimeDescription);
|
|
mMimeDescription = nsnull;
|
|
}
|
|
|
|
if (nsnull != mExtensions)
|
|
{
|
|
PR_Free(mExtensions);
|
|
mExtensions = nsnull;
|
|
}
|
|
|
|
if (nsnull != mMimeTypeArray)
|
|
{
|
|
PR_Free(mMimeTypeArray);
|
|
mMimeTypeArray = nsnull;
|
|
}
|
|
|
|
if (nsnull != mMimeDescriptionArray)
|
|
{
|
|
PR_Free(mMimeDescriptionArray);
|
|
mMimeDescriptionArray = nsnull;
|
|
}
|
|
|
|
if (nsnull != mExtensionsArray)
|
|
{
|
|
PR_Free(mExtensionsArray);
|
|
mExtensionsArray = nsnull;
|
|
}
|
|
|
|
if (nsnull != mLibrary)
|
|
{
|
|
PR_UnloadLibrary(mLibrary);
|
|
mLibrary = nsnull;
|
|
}
|
|
}
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
|
|
class nsPluginStreamInfo : public nsIPluginStreamInfo
|
|
{
|
|
public:
|
|
|
|
nsPluginStreamInfo();
|
|
~nsPluginStreamInfo();
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
// nsIPluginStreamInfo interface
|
|
|
|
NS_IMETHOD
|
|
GetContentType(nsMIMEType* result);
|
|
|
|
NS_IMETHOD
|
|
IsSeekable(PRBool* result);
|
|
|
|
NS_IMETHOD
|
|
GetLength(PRUint32* result);
|
|
|
|
NS_IMETHOD
|
|
GetLastModified(PRUint32* result);
|
|
|
|
NS_IMETHOD
|
|
RequestRead(nsByteRange* rangeList);
|
|
|
|
// local methods
|
|
|
|
void
|
|
SetContentType(const nsMIMEType result);
|
|
|
|
void
|
|
SetSeekable(const PRBool result);
|
|
|
|
void
|
|
SetLength(const PRUint32 result);
|
|
|
|
void
|
|
SetLastModified(const PRUint32 result);
|
|
|
|
private:
|
|
|
|
char* mContentType;
|
|
PRBool mSeekable;
|
|
PRUint32 mLength;
|
|
PRUint32 mModified;
|
|
};
|
|
|
|
nsPluginStreamInfo::nsPluginStreamInfo()
|
|
{
|
|
NS_INIT_REFCNT();
|
|
|
|
mContentType = nsnull;
|
|
mSeekable = PR_FALSE;
|
|
mLength = 0;
|
|
mModified = 0;
|
|
}
|
|
|
|
nsPluginStreamInfo::~nsPluginStreamInfo()
|
|
{
|
|
if(mContentType != nsnull)
|
|
PL_strfree(mContentType);
|
|
}
|
|
|
|
NS_IMPL_ADDREF(nsPluginStreamInfo)
|
|
NS_IMPL_RELEASE(nsPluginStreamInfo)
|
|
|
|
nsresult nsPluginStreamInfo::QueryInterface(const nsIID& aIID,
|
|
void** aInstancePtrResult)
|
|
{
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
|
|
if (nsnull == aInstancePtrResult)
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
if (aIID.Equals(kIPluginStreamInfoIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIPluginStreamInfo *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kISupportsIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsISupports *)((nsIStreamListener *)this));
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPluginStreamInfo::GetContentType(nsMIMEType* result)
|
|
{
|
|
*result = mContentType;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPluginStreamInfo::IsSeekable(PRBool* result)
|
|
{
|
|
*result = mSeekable;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPluginStreamInfo::GetLength(PRUint32* result)
|
|
{
|
|
*result = mLength;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPluginStreamInfo::GetLastModified(PRUint32* result)
|
|
{
|
|
*result = mModified;
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP
|
|
nsPluginStreamInfo::RequestRead(nsByteRange* rangeList)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
// local methods
|
|
|
|
void
|
|
nsPluginStreamInfo::SetContentType(const nsMIMEType contentType)
|
|
{
|
|
if(mContentType != nsnull)
|
|
PL_strfree(mContentType);
|
|
|
|
mContentType = PL_strdup(contentType);
|
|
}
|
|
|
|
void
|
|
nsPluginStreamInfo::SetSeekable(const PRBool seekable)
|
|
{
|
|
mSeekable = seekable;
|
|
}
|
|
|
|
void
|
|
nsPluginStreamInfo::SetLength(const PRUint32 length)
|
|
{
|
|
mLength = length;
|
|
}
|
|
|
|
void
|
|
nsPluginStreamInfo::SetLastModified(const PRUint32 modified)
|
|
{
|
|
mModified = modified;
|
|
}
|
|
|
|
#endif
|
|
|
|
class nsPluginStreamListenerPeer : public nsIStreamListener
|
|
{
|
|
public:
|
|
nsPluginStreamListenerPeer();
|
|
~nsPluginStreamListenerPeer();
|
|
|
|
NS_DECL_ISUPPORTS
|
|
|
|
//nsIStreamObserver interface
|
|
|
|
NS_IMETHOD OnStartBinding(nsIURL* aURL, const char *aContentType);
|
|
|
|
NS_IMETHOD OnProgress(nsIURL* aURL, PRUint32 aProgress, PRUint32 aProgressMax);
|
|
|
|
NS_IMETHOD OnStatus(nsIURL* aURL, const PRUnichar* aMsg);
|
|
|
|
NS_IMETHOD OnStopBinding(nsIURL* aURL, nsresult aStatus, const PRUnichar* aMsg);
|
|
|
|
//NS_IMETHOD OnNotify(nsIURL* aURL, nsresult aStatus, const PRUnichar* aMsg);
|
|
|
|
//nsIStreamListener interface
|
|
|
|
NS_IMETHOD GetBindInfo(nsIURL* aURL, nsStreamBindingInfo* aInfo);
|
|
|
|
NS_IMETHOD OnDataAvailable(nsIURL* aURL, nsIInputStream *aIStream,
|
|
PRUint32 aLength);
|
|
|
|
//locals
|
|
|
|
// Called by GetURL and PostURL (via NewStream)
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
nsresult Initialize(nsIURL *aURL, nsIPluginInstance *aInstance, nsIPluginStreamListener *aListener);
|
|
#else
|
|
nsresult Initialize(nsIURL *aURL, nsIPluginInstance *aInstance, void *aNotifyData);
|
|
#endif
|
|
|
|
nsresult InitializeEmbeded(nsIURL *aURL, nsIPluginInstance* aInstance, nsIPluginInstanceOwner *aOwner = nsnull,
|
|
nsIPluginHost *aHost = nsnull);
|
|
|
|
nsresult InitializeFullPage(nsIPluginInstance *aInstance);
|
|
|
|
private:
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
nsresult SetUpCache(nsIURL* aURL);
|
|
nsresult SetUpStreamListener(nsIURL* aURL);
|
|
#else
|
|
nsresult SetUpStreamPeer(nsIURL* aURL, nsIPluginInstance *instance,
|
|
const char* aContentType, PRInt32 aProgressMax = 0);
|
|
#endif
|
|
|
|
nsIURL *mURL;
|
|
nsIPluginInstanceOwner *mOwner;
|
|
nsIPluginInstance *mInstance;
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
nsIPluginStreamListener *mPStreamListener;
|
|
nsPluginStreamInfo *mPluginStreamInfo;
|
|
PRBool mSetUpListener;
|
|
#else
|
|
nsPluginStreamPeer *mPeer;
|
|
nsIPluginStream *mStream;
|
|
void *mNotifyData;
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
|
|
// these get passed to the plugin stream listener
|
|
char *mMIMEType;
|
|
PRUint32 mLength;
|
|
nsPluginStreamType mStreamType;
|
|
|
|
PRUint8 *mBuffer;
|
|
PRUint32 mBufSize;
|
|
nsIPluginHost *mHost;
|
|
PRBool mGotProgress;
|
|
PRBool mOnStartBinding;
|
|
|
|
#ifdef USE_CACHE
|
|
nsCacheObject* mCachedFile;
|
|
#else
|
|
FILE* mStreamFile;
|
|
#endif
|
|
};
|
|
|
|
nsPluginStreamListenerPeer :: nsPluginStreamListenerPeer()
|
|
{
|
|
NS_INIT_REFCNT();
|
|
|
|
mURL = nsnull;
|
|
mOwner = nsnull;
|
|
mInstance = nsnull;
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
mPStreamListener = nsnull;
|
|
mPluginStreamInfo = nsnull;
|
|
mSetUpListener = PR_FALSE;
|
|
#else
|
|
mPeer = nsnull;
|
|
mStream = nsnull;
|
|
mNotifyData = nsnull;
|
|
mMIMEType = nsnull;
|
|
mLength = 0;
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
|
|
mBuffer = nsnull;
|
|
mBufSize = 0;
|
|
mHost = nsnull;
|
|
mGotProgress = PR_FALSE;
|
|
mOnStartBinding = PR_FALSE;
|
|
mStreamType = nsPluginStreamType_Normal;
|
|
|
|
#ifdef USE_CACHE
|
|
mCachedFile = nsnull;
|
|
#else
|
|
mStreamFile = nsnull;
|
|
#endif
|
|
}
|
|
|
|
nsPluginStreamListenerPeer :: ~nsPluginStreamListenerPeer()
|
|
{
|
|
#ifdef NS_DEBUG
|
|
if(mURL != nsnull)
|
|
{
|
|
const char* spec;
|
|
(void)mURL->GetSpec(&spec);
|
|
printf("killing stream for %s\n", mURL ? spec : "(unknown URL)");
|
|
}
|
|
#endif
|
|
|
|
NS_IF_RELEASE(mURL);
|
|
NS_IF_RELEASE(mOwner);
|
|
NS_IF_RELEASE(mInstance);
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
NS_IF_RELEASE(mPStreamListener);
|
|
#else
|
|
NS_IF_RELEASE(mStream);
|
|
NS_IF_RELEASE(mPeer);
|
|
mNotifyData = nsnull;
|
|
|
|
if (nsnull != mMIMEType)
|
|
{
|
|
PR_Free(mMIMEType);
|
|
mMIMEType = nsnull;
|
|
}
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
|
|
if (nsnull != mBuffer)
|
|
{
|
|
PR_Free(mBuffer);
|
|
mBuffer = nsnull;
|
|
}
|
|
|
|
NS_IF_RELEASE(mHost);
|
|
|
|
#ifdef USE_CACHE
|
|
if (nsnull != mCachedFile)
|
|
{
|
|
delete mCachedFile;
|
|
mCachedFile = nsnull;
|
|
}
|
|
#else // USE_CACHE
|
|
if(nsnull != mStreamFile)
|
|
{
|
|
fclose(mStreamFile);
|
|
mStreamFile = nsnull;
|
|
}
|
|
#endif // USE_CACHE
|
|
}
|
|
|
|
NS_IMPL_ADDREF(nsPluginStreamListenerPeer)
|
|
NS_IMPL_RELEASE(nsPluginStreamListenerPeer)
|
|
|
|
nsresult nsPluginStreamListenerPeer :: QueryInterface(const nsIID& aIID,
|
|
void** aInstancePtrResult)
|
|
{
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
|
|
if (nsnull == aInstancePtrResult)
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
if (aIID.Equals(kIStreamListenerIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIStreamListener *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kIStreamObserverIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIStreamObserver *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kISupportsIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsISupports *)((nsIStreamListener *)this));
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
|
|
/* Called as a result of GetURL and PostURL */
|
|
|
|
nsresult nsPluginStreamListenerPeer :: Initialize(nsIURL *aURL, nsIPluginInstance *aInstance,
|
|
nsIPluginStreamListener* aListener)
|
|
{
|
|
#ifdef NS_DEBUG
|
|
const char* spec;
|
|
(void)aURL->GetSpec(&spec);
|
|
printf("created stream for %s\n", spec);
|
|
#endif
|
|
|
|
mURL = aURL;
|
|
NS_ADDREF(mURL);
|
|
|
|
mInstance = aInstance;
|
|
NS_ADDREF(mInstance);
|
|
|
|
mPStreamListener = aListener;
|
|
NS_ADDREF(mPStreamListener);
|
|
|
|
mPluginStreamInfo = new nsPluginStreamInfo();
|
|
//mPStreamListener->GetStreamType(&mStreamType);
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#else
|
|
|
|
/* Called as a result of GetURL and PostURL - NewPluginURLStream() */
|
|
|
|
nsresult nsPluginStreamListenerPeer :: Initialize(nsIURL *aURL, nsIPluginInstance *aInstance, void *aNotifyData)
|
|
{
|
|
#ifdef NS_DEBUG
|
|
const char* spec;
|
|
(void)aURL->GetSpec(&spec);
|
|
printf("created stream for %s\n", spec);
|
|
#endif
|
|
mURL = aURL;
|
|
NS_ADDREF(mURL);
|
|
|
|
mInstance = aInstance;
|
|
NS_ADDREF(mInstance);
|
|
|
|
mNotifyData = aNotifyData;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#endif
|
|
|
|
/*
|
|
Called by NewEmbededPluginStream() - if this is called, we weren't able to load the plugin,
|
|
so we need to load it later once we figure out the mimetype. In order to load it later,
|
|
we need the plugin host and instance owner.
|
|
*/
|
|
|
|
nsresult nsPluginStreamListenerPeer :: InitializeEmbeded(nsIURL *aURL, nsIPluginInstance* aInstance,
|
|
nsIPluginInstanceOwner *aOwner,
|
|
nsIPluginHost *aHost)
|
|
{
|
|
#ifdef NS_DEBUG
|
|
const char* spec;
|
|
(void)aURL->GetSpec(&spec);
|
|
printf("created stream for %s\n", spec);
|
|
#endif
|
|
|
|
mURL = aURL;
|
|
NS_ADDREF(mURL);
|
|
|
|
if(aInstance != nsnull)
|
|
{
|
|
mInstance = aInstance;
|
|
NS_ADDREF(mInstance);
|
|
}
|
|
else
|
|
{
|
|
mOwner = aOwner;
|
|
NS_IF_ADDREF(mOwner);
|
|
|
|
mHost = aHost;
|
|
NS_IF_ADDREF(mHost);
|
|
}
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
mPluginStreamInfo = new nsPluginStreamInfo();
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* Called by NewFullPagePluginStream() */
|
|
|
|
nsresult nsPluginStreamListenerPeer :: InitializeFullPage(nsIPluginInstance *aInstance)
|
|
{
|
|
#ifdef NS_DEBUG
|
|
printf("created stream for (unknown URL)\n");
|
|
#endif
|
|
|
|
mInstance = aInstance;
|
|
NS_ADDREF(mInstance);
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
mPluginStreamInfo = new nsPluginStreamInfo();
|
|
#endif
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer::OnStartBinding(nsIURL* aURL, const char *aContentType)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
if (nsnull != aContentType)
|
|
{
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
mPluginStreamInfo->SetContentType(aContentType);
|
|
#else
|
|
PRInt32 len = PL_strlen(aContentType);
|
|
mMIMEType = (char *)PR_Malloc(len + 1);
|
|
|
|
if (nsnull != mMIMEType)
|
|
PL_strcpy(mMIMEType, aContentType);
|
|
else
|
|
rv = NS_ERROR_OUT_OF_MEMORY;
|
|
#endif
|
|
}
|
|
|
|
nsPluginWindow *window = nsnull;
|
|
|
|
// if we don't have an nsIPluginInstance (mInstance), it means
|
|
// we weren't able to load a plugin previously because we
|
|
// didn't have the mimetype. Now that we do (aContentType),
|
|
// we'll try again with SetUpPluginInstance()
|
|
|
|
if ((nsnull == mInstance) && (nsnull != mOwner))
|
|
{
|
|
mOwner->GetInstance(mInstance);
|
|
mOwner->GetWindow(window);
|
|
|
|
if ((nsnull == mInstance) && (nsnull != mHost) && (nsnull != window))
|
|
{
|
|
rv = mHost->SetUpPluginInstance(aContentType, aURL, mOwner);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
// GetInstance() adds a ref
|
|
mOwner->GetInstance(mInstance);
|
|
|
|
if (nsnull != mInstance)
|
|
{
|
|
mInstance->Start();
|
|
mOwner->CreateWidget();
|
|
mInstance->SetWindow(window);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
// only set up the stream listener if we have both the mimetype and
|
|
// have mLength set (as indicated by the mGotProgress bool)
|
|
if(mGotProgress == PR_TRUE && mSetUpListener == PR_FALSE)
|
|
rv = SetUpStreamListener(aURL);
|
|
#else
|
|
if ((PR_TRUE == mGotProgress) && (nsnull == mPeer) && (nsnull != mInstance))
|
|
rv = SetUpStreamPeer(aURL, mInstance, aContentType);
|
|
#endif
|
|
|
|
mOnStartBinding = PR_TRUE;
|
|
return rv;
|
|
}
|
|
|
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer :: OnProgress(nsIURL* aURL, PRUint32 aProgress, PRUint32 aProgressMax)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
|
|
mPluginStreamInfo->SetLength(aProgressMax);
|
|
// if OnStartBinding already got called,
|
|
if(mOnStartBinding == PR_TRUE && mSetUpListener == PR_FALSE)
|
|
rv = SetUpStreamListener(aURL);
|
|
#else
|
|
|
|
mLength = aProgressMax;
|
|
if ((aProgress == 0) && (nsnull == mPeer))
|
|
{
|
|
nsIPluginInstance *instance = nsnull;
|
|
|
|
if (nsnull == mInstance)
|
|
mOwner->GetInstance(instance);
|
|
else
|
|
{
|
|
instance = mInstance;
|
|
NS_ADDREF(instance);
|
|
}
|
|
|
|
if (nsnull != instance)
|
|
{
|
|
rv = SetUpStreamPeer(aURL, instance, nsnull, aProgressMax);
|
|
NS_RELEASE(instance);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
mGotProgress = PR_TRUE;
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer :: OnStatus(nsIURL* aURL, const PRUnichar* aMsg)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer :: GetBindInfo(nsIURL* aURL, nsStreamBindingInfo* aInfo)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer :: OnDataAvailable(nsIURL* aURL, nsIInputStream *aIStream,
|
|
PRUint32 aLength)
|
|
{
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
nsresult rv;
|
|
const char* url;
|
|
aURL->GetSpec(&url);
|
|
rv = mPStreamListener->OnDataAvailable(url, aIStream, 0, aLength,(nsIPluginStreamInfo*)mPluginStreamInfo);
|
|
return rv;
|
|
#else
|
|
if (aLength > mBufSize)
|
|
{
|
|
if (nsnull != mBuffer)
|
|
PR_Free((void *)mBuffer);
|
|
|
|
mBuffer = (PRUint8 *)PR_Malloc(aLength);
|
|
mBufSize = aLength;
|
|
}
|
|
|
|
if ((nsnull != mBuffer) && (nsnull != mStream))
|
|
{
|
|
PRUint32 readlen;
|
|
aIStream->Read((char *)mBuffer, 0, aLength, &readlen);
|
|
|
|
#ifdef USE_CACHE
|
|
if(nsnull != mCachedFile)
|
|
mCachedFile->Write((char*)mBuffer, aLength);
|
|
#else
|
|
if(nsnull != mStreamFile)
|
|
fwrite(mBuffer, 1, aLength, mStreamFile);
|
|
#endif
|
|
|
|
if (mStreamType != nsPluginStreamType_AsFileOnly)
|
|
mStream->Write((char *)mBuffer, 0, aLength, &readlen);
|
|
}
|
|
|
|
return NS_OK;
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginStreamListenerPeer :: OnStopBinding(nsIURL* aURL, nsresult aStatus, const PRUnichar* aMsg)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
nsPluginReason reason = nsPluginReason_NoReason;
|
|
|
|
//XXX this is incomplete... MMP
|
|
#ifndef NEW_PLUGIN_STREAM_API
|
|
if (nsnull != mPeer)
|
|
{
|
|
if (aStatus == NS_BINDING_SUCCEEDED)
|
|
reason = nsPluginReason_Done;
|
|
else
|
|
reason = nsPluginReason_UserBreak;
|
|
|
|
mPeer->SetReason(reason);
|
|
|
|
rv = NS_OK;
|
|
}
|
|
else
|
|
rv = NS_ERROR_UNEXPECTED;
|
|
#endif
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
if(nsnull != mPStreamListener)
|
|
#else
|
|
if (nsnull != mStream)
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
{
|
|
if ((mStreamType == nsPluginStreamType_AsFile) ||
|
|
(mStreamType == nsPluginStreamType_AsFileOnly))
|
|
{
|
|
#ifdef USE_CACHE
|
|
if (nsnull != mCachedFile)
|
|
{
|
|
PRInt32 len;
|
|
nsCachePref* cachePref = nsCachePref::GetInstance();
|
|
|
|
const char* cachePath = cachePref->DiskCacheFolder();
|
|
const char* filename = mCachedFile->Filename();
|
|
|
|
// we need to pass the whole path and filename to the plugin
|
|
len = PL_strlen(cachePath) + PL_strlen(filename) + 1;
|
|
char* pathAndFilename = (char*)PR_Malloc(len * sizeof(char));
|
|
pathAndFilename = PL_strcpy(pathAndFilename, cachePath);
|
|
pathAndFilename = PL_strcat(pathAndFilename, filename);
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
const char* urlString;
|
|
aURL->GetSpec(&urlString);
|
|
if (mPStreamListener)
|
|
mPStreamListener->OnFileAvailable(urlString, pathAndFilename);
|
|
#else
|
|
mStream->AsFile(pathAndFilename);
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
}
|
|
#else // USE_CACHE
|
|
if(nsnull != mStreamFile)
|
|
{
|
|
fclose(mStreamFile);
|
|
mStreamFile = nsnull;
|
|
|
|
char buf[400], tpath[300];
|
|
#ifdef XP_PC
|
|
::GetTempPath(sizeof(tpath), tpath);
|
|
PRInt32 len = PL_strlen(tpath);
|
|
|
|
if((len > 0) && (tpath[len-1] != '\\'))
|
|
{
|
|
tpath[len] = '\\';
|
|
tpath[len+1] = 0;
|
|
}
|
|
#elif defined (XP_UNIX)
|
|
PL_strcpy(tpath, "/tmp/");
|
|
#else
|
|
tpath[0] = 0;
|
|
#endif // XP_PC
|
|
PR_snprintf(buf, sizeof(buf), "%s%08X.ngl", tpath, this);
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
const char* urlString;
|
|
aURL->GetSpec(&urlString);
|
|
if (mPStreamListener)
|
|
mPStreamListener->OnFileAvailable(urlString, buf);
|
|
#else
|
|
mStream->AsFile(buf);
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
}
|
|
#endif // USE_CACHE
|
|
}
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
const char* url;
|
|
aURL->GetSpec(&url);
|
|
if (mPStreamListener)
|
|
{
|
|
mPStreamListener->OnStopBinding(url, aStatus, (nsIPluginStreamInfo*)mPluginStreamInfo);
|
|
mPStreamListener->OnNotify(url, aStatus);
|
|
}
|
|
#else
|
|
nsIPluginInstance *instance = nsnull;
|
|
|
|
if (nsnull == mInstance)
|
|
mOwner->GetInstance(instance);
|
|
else
|
|
{
|
|
instance = mInstance;
|
|
NS_ADDREF(instance);
|
|
}
|
|
|
|
mStream->Close();
|
|
|
|
if (nsnull != instance)
|
|
{
|
|
if (nsnull != mNotifyData)
|
|
{
|
|
const char *url;
|
|
|
|
if (nsnull != mURL)
|
|
rv = mURL->GetSpec(&url);
|
|
else
|
|
url = "";
|
|
|
|
//XXX target is bad. MMP
|
|
if (url)
|
|
instance->URLNotify(url, "", reason, mNotifyData);
|
|
}
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
|
|
/*NS_IMETHODIMP nsPluginStreamListenerPeer :: OnNotify(nsIURL* aURL, nsresult aStatus, const PRUnichar* aMsg)
|
|
{
|
|
return NS_OK;
|
|
}*/
|
|
|
|
|
|
// private methods for nsPluginStreamListenerPeer
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
|
|
nsresult nsPluginStreamListenerPeer::SetUpCache(nsIURL* aURL)
|
|
{
|
|
#ifdef USE_CACHE
|
|
nsString urlString;
|
|
char* cString;
|
|
|
|
aURL->ToString(urlString);
|
|
cString = urlString.ToNewCString();
|
|
mCachedFile = new nsCacheObject(cString);
|
|
delete [] cString;
|
|
|
|
if(mCachedFile == nsnull)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
// use the actual filename of the net-based file as the cache filename
|
|
mCachedFile->Filename(aURL->GetFile());
|
|
|
|
nsCacheManager* cacheManager = nsCacheManager::GetInstance();
|
|
nsDiskModule* diskCache = cacheManager->GetDiskModule();
|
|
diskCache->AddObject(mCachedFile);
|
|
#else // USE_CACHE
|
|
char buf[400], tpath[300];
|
|
#ifdef XP_PC
|
|
::GetTempPath(sizeof(tpath), tpath);
|
|
PRInt32 len = PL_strlen(tpath);
|
|
|
|
if((len > 0) && (tpath[len-1] != '\\'))
|
|
{
|
|
tpath[len] = '\\';
|
|
tpath[len+1] = 0;
|
|
}
|
|
#elif defined (XP_UNIX)
|
|
PL_strcpy(tpath, "/tmp/");
|
|
#else
|
|
tpath[0] = 0;
|
|
#endif // XP_PC
|
|
PR_snprintf(buf, sizeof(buf), "%s%08X.ngl", tpath, this);
|
|
mStreamFile = fopen(buf, "wb");
|
|
#endif // USE_CACHE
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsPluginStreamListenerPeer::SetUpStreamListener(nsIURL* aURL)
|
|
{
|
|
nsresult rv = NS_OK;
|
|
|
|
// If we don't yet have a stream listener, we need to get one from the plugin.
|
|
// NOTE: this should only happen when a stream was NOT created with GetURL or
|
|
// PostURL (i.e. it's the initial stream we send to the plugin as determined
|
|
// by the SRC or DATA attribute)
|
|
if(mPStreamListener == nsnull && mInstance != nsnull)
|
|
rv = mInstance->NewStream(&mPStreamListener);
|
|
|
|
if(rv != NS_OK)
|
|
return rv;
|
|
|
|
if(mPStreamListener == nsnull)
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
mSetUpListener = PR_TRUE;
|
|
|
|
mPStreamListener->GetStreamType(&mStreamType);
|
|
if ((mStreamType == nsPluginStreamType_AsFile) ||
|
|
(mStreamType == nsPluginStreamType_AsFileOnly))
|
|
SetUpCache(aURL);
|
|
|
|
mPluginStreamInfo->SetSeekable(PR_FALSE);
|
|
//mPluginStreamInfo->SetModified(??);
|
|
|
|
const char* urlString;
|
|
aURL->GetSpec(&urlString);
|
|
return mPStreamListener->OnStartBinding(urlString, (nsIPluginStreamInfo*)mPluginStreamInfo);
|
|
}
|
|
|
|
#else
|
|
|
|
nsresult nsPluginStreamListenerPeer::SetUpStreamPeer(nsIURL* aURL, nsIPluginInstance *instance,
|
|
const char* aContentType, PRInt32 aProgressMax)
|
|
{
|
|
mPeer = (nsPluginStreamPeer *)new nsPluginStreamPeer();
|
|
if(mPeer == nsnull)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
NS_ADDREF(mPeer);
|
|
|
|
if(aContentType != nsnull)
|
|
mPeer->Initialize(aURL, mLength, 0, aContentType, mNotifyData);
|
|
else
|
|
mPeer->Initialize(aURL, aProgressMax, 0, mMIMEType, mNotifyData);
|
|
|
|
instance->NewStream(mPeer, &mStream);
|
|
|
|
if (nsnull != mStream)
|
|
mStream->GetStreamType(&mStreamType);
|
|
|
|
// check to see if we need to cache the file
|
|
if ((mStreamType == nsPluginStreamType_AsFile) ||
|
|
(mStreamType == nsPluginStreamType_AsFileOnly))
|
|
{
|
|
#ifdef USE_CACHE
|
|
nsString urlString;
|
|
char* cString;
|
|
|
|
aURL->ToString(urlString);
|
|
cString = urlString.ToNewCString();
|
|
mCachedFile = new nsCacheObject(cString);
|
|
delete [] cString;
|
|
|
|
if(mCachedFile == nsnull)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
// use the actual filename of the net-based file as the cache filename
|
|
//mCachedFile->Filename(aURL->GetFile());
|
|
mCachedFile->Filename("xmas1.mid");
|
|
|
|
nsCacheManager* cacheManager = nsCacheManager::GetInstance();
|
|
nsDiskModule* diskCache = cacheManager->GetDiskModule();
|
|
diskCache->AddObject(mCachedFile);
|
|
#else // USE_CACHE
|
|
char buf[400], tpath[300];
|
|
#ifdef XP_PC
|
|
::GetTempPath(sizeof(tpath), tpath);
|
|
PRInt32 len = PL_strlen(tpath);
|
|
|
|
if((len > 0) && (tpath[len-1] != '\\'))
|
|
{
|
|
tpath[len] = '\\';
|
|
tpath[len+1] = 0;
|
|
}
|
|
#elif defined (XP_UNIX)
|
|
PL_strcpy(tpath, "/tmp/");
|
|
#else
|
|
tpath[0] = 0;
|
|
#endif // XP_PC
|
|
PR_snprintf(buf, sizeof(buf), "%s%08X.ngl", tpath, this);
|
|
mStreamFile = fopen(buf, "wb");
|
|
#endif // USE_CACHE
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
|
|
nsPluginHostImpl :: nsPluginHostImpl(nsIServiceManager *serviceMgr)
|
|
{
|
|
NS_INIT_REFCNT();
|
|
mPluginsLoaded = PR_FALSE;
|
|
mServiceMgr = serviceMgr;
|
|
}
|
|
|
|
nsPluginHostImpl :: ~nsPluginHostImpl()
|
|
{
|
|
#ifdef NS_DEBUG
|
|
printf("killing plugin host\n");
|
|
#endif
|
|
if (nsnull != mPluginPath)
|
|
{
|
|
PR_Free(mPluginPath);
|
|
mPluginPath = nsnull;
|
|
}
|
|
|
|
while (nsnull != mPlugins)
|
|
{
|
|
nsPluginTag *temp = mPlugins->mNext;
|
|
delete mPlugins;
|
|
mPlugins = temp;
|
|
}
|
|
}
|
|
|
|
NS_IMPL_ADDREF(nsPluginHostImpl)
|
|
NS_IMPL_RELEASE(nsPluginHostImpl)
|
|
|
|
nsresult nsPluginHostImpl :: QueryInterface(const nsIID& aIID,
|
|
void** aInstancePtrResult)
|
|
{
|
|
NS_PRECONDITION(nsnull != aInstancePtrResult, "null pointer");
|
|
|
|
if (nsnull == aInstancePtrResult)
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
if (aIID.Equals(kIPluginManagerIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIPluginManager *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kIPluginManager2IID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIPluginManager2 *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kIPluginHostIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIPluginHost *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kIFactoryIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsIFactory *)this);
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kIFileUtilitiesIID))
|
|
{
|
|
*aInstancePtrResult = (void*)(nsIFileUtilities*)this;
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
if (aIID.Equals(kISupportsIID))
|
|
{
|
|
*aInstancePtrResult = (void *)((nsISupports *)((nsIPluginHost *)this));
|
|
AddRef();
|
|
return NS_OK;
|
|
}
|
|
|
|
return NS_NOINTERFACE;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: GetValue(nsPluginManagerVariable variable, void *value)
|
|
{
|
|
printf("manager getvalue %d called\n", variable);
|
|
return NS_OK;
|
|
}
|
|
|
|
nsresult nsPluginHostImpl :: ReloadPlugins(PRBool reloadPages)
|
|
{
|
|
mPluginsLoaded = PR_FALSE;
|
|
return LoadPlugins();
|
|
}
|
|
|
|
nsresult nsPluginHostImpl :: UserAgent(const char **retstring)
|
|
{
|
|
nsresult res;
|
|
|
|
#ifdef USE_NETLIB_FOR_USER_AGENT
|
|
nsString ua;
|
|
nsINetService *service = nsnull;
|
|
|
|
res = nsServiceManager::GetService(kNetServiceCID,
|
|
kINetServiceIID,
|
|
(nsISupports **)&service);
|
|
if ((NS_OK == res) && (nsnull != service))
|
|
{
|
|
res = service->GetUserAgent(ua);
|
|
|
|
if (NS_OK == res)
|
|
*retstring = ua.ToNewCString();
|
|
else
|
|
*retstring = nsnull;
|
|
|
|
NS_RELEASE(service);
|
|
}
|
|
#else
|
|
*retstring = (const char *)"Mozilla/5.0 [en] (Windows;I)";
|
|
res = NS_OK;
|
|
#endif
|
|
|
|
return res;
|
|
}
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetURL(nsISupports* pluginInst,
|
|
const char* url,
|
|
const char* target,
|
|
nsIPluginStreamListener* streamListener,
|
|
const char* altHost,
|
|
const char* referrer,
|
|
PRBool forceJSEnabled)
|
|
{
|
|
nsAutoString string = nsAutoString(url);
|
|
nsIPluginInstance *instance;
|
|
nsresult rv;
|
|
|
|
// we can only send a stream back to the plugin (as specified by a null target)
|
|
// if we also have a nsIPluginStreamListener to talk to also
|
|
if(target == nsnull && streamListener == nsnull)
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
rv = pluginInst->QueryInterface(kIPluginInstanceIID, (void **)&instance);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if (nsnull != target)
|
|
{
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
rv = instance->GetPeer((nsIPluginInstancePeer **)&peer);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
nsIPluginInstanceOwner *owner;
|
|
|
|
rv = peer->GetOwner(owner);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if ((0 == PL_strcmp(target, "newwindow")) ||
|
|
(0 == PL_strcmp(target, "_new")))
|
|
target = "_blank";
|
|
else if (0 == PL_strcmp(target, "_current"))
|
|
target = "_self";
|
|
|
|
rv = owner->GetURL(url, target, nsnull);
|
|
NS_RELEASE(owner);
|
|
}
|
|
|
|
NS_RELEASE(peer);
|
|
}
|
|
}
|
|
|
|
if (nsnull != streamListener)
|
|
rv = NewPluginURLStream(string, instance, streamListener);
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::PostURL(nsISupports* pluginInst,
|
|
const char* url,
|
|
PRUint32 postDataLen,
|
|
const char* postData,
|
|
PRBool isFile,
|
|
const char* target,
|
|
nsIPluginStreamListener* streamListener,
|
|
const char* altHost,
|
|
const char* referrer,
|
|
PRBool forceJSEnabled,
|
|
PRUint32 postHeadersLength,
|
|
const char* postHeaders)
|
|
{
|
|
nsAutoString string = nsAutoString(url);
|
|
nsIPluginInstance *instance;
|
|
nsresult rv;
|
|
|
|
// we can only send a stream back to the plugin (as specified by a null target)
|
|
// if we also have a nsIPluginStreamListener to talk to also
|
|
if(target == nsnull && streamListener == nsnull)
|
|
return NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
rv = pluginInst->QueryInterface(kIPluginInstanceIID, (void **)&instance);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if (nsnull != target)
|
|
{
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
rv = instance->GetPeer((nsIPluginInstancePeer **)&peer);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
nsIPluginInstanceOwner *owner;
|
|
|
|
rv = peer->GetOwner(owner);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if ((0 == PL_strcmp(target, "newwindow")) ||
|
|
(0 == PL_strcmp(target, "_new")))
|
|
target = "_blank";
|
|
else if (0 == PL_strcmp(target, "_current"))
|
|
target = "_self";
|
|
|
|
rv = owner->GetURL(url, target, (void*)postData);
|
|
NS_RELEASE(owner);
|
|
}
|
|
|
|
NS_RELEASE(peer);
|
|
}
|
|
}
|
|
|
|
if (streamListener != nsnull)
|
|
rv = NewPluginURLStream(string, instance, streamListener);
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
#else
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: GetURL(nsISupports* inst, const char* url,
|
|
const char* target,
|
|
void* notifyData, const char* altHost,
|
|
const char* referrer, PRBool forceJSEnabled)
|
|
{
|
|
nsAutoString string = nsAutoString(url);
|
|
nsIPluginInstance *instance;
|
|
nsresult rv;
|
|
|
|
rv = inst->QueryInterface(kIPluginInstanceIID, (void **)&instance);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if (nsnull != target)
|
|
{
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
rv = instance->GetPeer((nsIPluginInstancePeer **)&peer);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
nsIPluginInstanceOwner *owner;
|
|
|
|
rv = peer->GetOwner(owner);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if ((0 == PL_strcmp(target, "newwindow")) ||
|
|
(0 == PL_strcmp(target, "_new")))
|
|
target = "_blank";
|
|
else if (0 == PL_strcmp(target, "_current"))
|
|
target = "_self";
|
|
|
|
rv = owner->GetURL(url, target, nsnull);
|
|
NS_RELEASE(owner);
|
|
}
|
|
|
|
NS_RELEASE(peer);
|
|
}
|
|
}
|
|
|
|
if ((nsnull != notifyData) || (nsnull == target))
|
|
rv = NewPluginURLStream(string, instance, notifyData);
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: PostURL(nsISupports* inst,
|
|
const char* url, const char* target,
|
|
PRUint32 postDataLen, const char* postData,
|
|
PRBool isFile, void* notifyData,
|
|
const char* altHost, const char* referrer,
|
|
PRBool forceJSEnabled,
|
|
PRUint32 postHeadersLength, const char* postHeaders)
|
|
{
|
|
|
|
nsAutoString string = nsAutoString(url);
|
|
nsIPluginInstance *instance;
|
|
nsresult rv;
|
|
|
|
rv = inst->QueryInterface(kIPluginInstanceIID, (void **)&instance);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if (nsnull != target)
|
|
{
|
|
nsPluginInstancePeerImpl *peer;
|
|
|
|
rv = instance->GetPeer((nsIPluginInstancePeer **)&peer);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
nsIPluginInstanceOwner *owner;
|
|
|
|
rv = peer->GetOwner(owner);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
if ((0 == PL_strcmp(target, "newwindow")) ||
|
|
(0 == PL_strcmp(target, "_new")))
|
|
target = "_blank";
|
|
else if (0 == PL_strcmp(target, "_current"))
|
|
target = "_self";
|
|
|
|
rv = owner->GetURL(url, target, (void*)postData);
|
|
NS_RELEASE(owner);
|
|
}
|
|
|
|
NS_RELEASE(peer);
|
|
}
|
|
}
|
|
|
|
if ((nsnull != notifyData) || (nsnull == target))
|
|
rv = NewPluginURLStream(string, instance, notifyData);
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
#endif // NEW_PLUGIN_STREAM_API
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: BeginWaitCursor(void)
|
|
{
|
|
printf("plugin manager2 beginwaitcursor called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: EndWaitCursor(void)
|
|
{
|
|
printf("plugin manager2 posturl called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: SupportsURLProtocol(const char* protocol, PRBool *result)
|
|
{
|
|
printf("plugin manager2 supportsurlprotocol called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: NotifyStatusChange(nsIPlugin* plugin, nsresult errorStatus)
|
|
{
|
|
printf("plugin manager2 notifystatuschange called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: FindProxyForURL(const char* url, char* *result)
|
|
{
|
|
printf("plugin manager2 findproxyforurl called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: RegisterWindow(nsIEventHandler* handler, nsPluginPlatformWindowRef window)
|
|
{
|
|
printf("plugin manager2 registerwindow called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: UnregisterWindow(nsIEventHandler* handler, nsPluginPlatformWindowRef window)
|
|
{
|
|
printf("plugin manager2 unregisterwindow called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: AllocateMenuID(nsIEventHandler* handler, PRBool isSubmenu, PRInt16 *result)
|
|
{
|
|
printf("plugin manager2 allocatemenuid called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: DeallocateMenuID(nsIEventHandler* handler, PRInt16 menuID)
|
|
{
|
|
printf("plugin manager2 deallocatemenuid called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: HasAllocatedMenuID(nsIEventHandler* handler, PRInt16 menuID, PRBool *result)
|
|
{
|
|
printf("plugin manager2 hasallocatedmenuid called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: ProcessNextEvent(PRBool *bEventHandled)
|
|
{
|
|
printf("plugin manager2 processnextevent called\n");
|
|
return NS_ERROR_NOT_IMPLEMENTED;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: Init(void)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::Destroy(void)
|
|
{
|
|
nsPluginTag *plug = mPlugins;
|
|
|
|
while (nsnull != plug)
|
|
{
|
|
if (nsnull != plug->mEntryPoint)
|
|
plug->mEntryPoint->Shutdown();
|
|
|
|
plug = plug->mNext;
|
|
}
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
/* Called by nsPluginInstanceOwner (nsObjectFrame.cpp - embeded case) */
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::InstantiateEmbededPlugin(const char *aMimeType, nsString& aURLSpec,
|
|
nsIPluginInstanceOwner *aOwner)
|
|
{
|
|
nsresult rv;
|
|
|
|
rv = SetUpPluginInstance(aMimeType, nsnull, aOwner);
|
|
|
|
if ((rv != NS_OK) || (nsnull == aMimeType))
|
|
{
|
|
//either the plugin could not be identified based
|
|
//on the mime type or there was no mime type
|
|
|
|
if (aURLSpec.Length() > 0)
|
|
{
|
|
//we need to stream in enough to get the mime type...
|
|
|
|
rv = NewEmbededPluginStream(aURLSpec, aOwner, nsnull);
|
|
}
|
|
else
|
|
rv = NS_ERROR_FAILURE;
|
|
}
|
|
else
|
|
{
|
|
nsIPluginInstance *instance = nsnull;
|
|
nsPluginWindow *window = nsnull;
|
|
|
|
//we got a plugin built, now stream
|
|
|
|
aOwner->GetInstance(instance);
|
|
aOwner->GetWindow(window);
|
|
|
|
if (nsnull != instance)
|
|
{
|
|
instance->Start();
|
|
aOwner->CreateWidget();
|
|
instance->SetWindow(window);
|
|
|
|
rv = NewEmbededPluginStream(aURLSpec, nsnull, instance);
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/* Called by nsPluginViewer.cpp (full-page case) */
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::InstantiateFullPagePlugin(const char *aMimeType, nsString& aURLSpec,
|
|
nsIStreamListener *&aStreamListener,
|
|
nsIPluginInstanceOwner *aOwner)
|
|
{
|
|
nsresult rv;
|
|
nsIURL *url;
|
|
|
|
//create a URL so that the instantiator can do file ext.
|
|
//based plugin lookups...
|
|
|
|
rv = NS_NewURL(&url, aURLSpec);
|
|
|
|
if (rv != NS_OK)
|
|
url = nsnull;
|
|
|
|
rv = SetUpPluginInstance(aMimeType, url, aOwner);
|
|
|
|
NS_IF_RELEASE(url);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
nsIPluginInstance *instance = nsnull;
|
|
nsPluginWindow *window = nsnull;
|
|
|
|
//we got a plugin built, now stream
|
|
|
|
aOwner->GetInstance(instance);
|
|
aOwner->GetWindow(window);
|
|
|
|
if (nsnull != instance)
|
|
{
|
|
instance->Start();
|
|
aOwner->CreateWidget();
|
|
instance->SetWindow(window);
|
|
|
|
rv = NewFullPagePluginStream(aStreamListener, instance);
|
|
|
|
NS_RELEASE(instance);
|
|
}
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
#ifdef XP_MAC
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::SetUpPluginInstance(const char *aMimeType,
|
|
nsIURL *aURL,
|
|
nsIPluginInstanceOwner *aOwner)
|
|
{
|
|
nsresult result = NS_ERROR_FAILURE;
|
|
nsIPlugin* plugin = NULL;
|
|
if (GetPluginFactory(aMimeType, &plugin) == NS_OK) {
|
|
// instantiate a plugin.
|
|
nsIPluginInstance* instance = NULL;
|
|
if (plugin->CreateInstance(NULL, kIPluginInstanceIID, (void **)&instance) == NS_OK) {
|
|
aOwner->SetInstance(instance);
|
|
|
|
nsPluginInstancePeerImpl *peer = new nsPluginInstancePeerImpl();
|
|
|
|
// set up the peer for the instance
|
|
peer->Initialize(aOwner, aMimeType); // this will not add a ref to the instance (or owner). MMP
|
|
|
|
// tell the plugin instance to initialize itself and pass in the peer.
|
|
instance->Initialize(peer);
|
|
NS_RELEASE(instance);
|
|
result = NS_OK;
|
|
}
|
|
NS_RELEASE(plugin);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
#else
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::SetUpPluginInstance(const char *aMimeType,
|
|
nsIURL *aURL,
|
|
nsIPluginInstanceOwner *aOwner)
|
|
{
|
|
nsPluginTag *plugins = nsnull;
|
|
PRInt32 variants, cnt;
|
|
|
|
if (PR_FALSE == mPluginsLoaded)
|
|
LoadPlugins();
|
|
|
|
// if we have a mimetype passed in, search the mPlugins linked list for a match
|
|
if (nsnull != aMimeType)
|
|
{
|
|
plugins = mPlugins;
|
|
|
|
while (nsnull != plugins)
|
|
{
|
|
variants = plugins->mVariants;
|
|
|
|
for (cnt = 0; cnt < variants; cnt++)
|
|
{
|
|
if (0 == strcmp(plugins->mMimeTypeArray[cnt], aMimeType))
|
|
break;
|
|
}
|
|
|
|
if (cnt < variants)
|
|
break;
|
|
|
|
plugins = plugins->mNext;
|
|
}
|
|
}
|
|
|
|
// if plugins is nsnull, then we have not been passed a mimetype,
|
|
// so look based on file extension
|
|
if ((nsnull == plugins) && (nsnull != aURL))
|
|
{
|
|
const char *name;
|
|
nsresult rv = aURL->GetSpec(&name);
|
|
if (rv != NS_OK) return rv;
|
|
PRInt32 len = PL_strlen(name);
|
|
|
|
//find the plugin by filename extension.
|
|
|
|
if ((nsnull != name) && (len > 1))
|
|
{
|
|
len--;
|
|
|
|
while ((name[len] != 0) && (name[len] != '.'))
|
|
len--;
|
|
|
|
if (name[len] == '.')
|
|
{
|
|
const char *ext = name + len + 1;
|
|
|
|
len = PL_strlen(ext);
|
|
|
|
plugins = mPlugins;
|
|
|
|
while (nsnull != plugins)
|
|
{
|
|
variants = plugins->mVariants;
|
|
|
|
for (cnt = 0; cnt < variants; cnt++)
|
|
{
|
|
char *extensions = plugins->mExtensionsArray[cnt];
|
|
char *nextexten;
|
|
PRInt32 extlen;
|
|
|
|
while (nsnull != extensions)
|
|
{
|
|
nextexten = strchr(extensions, ',');
|
|
|
|
if (nsnull != nextexten)
|
|
extlen = nextexten - extensions;
|
|
else
|
|
extlen = PL_strlen(extensions);
|
|
|
|
if (extlen == len)
|
|
{
|
|
if (PL_strncasecmp(extensions, ext, extlen) == 0)
|
|
break;
|
|
}
|
|
|
|
if (nsnull != nextexten)
|
|
extensions = nextexten + 1;
|
|
else
|
|
extensions = nsnull;
|
|
}
|
|
|
|
if (nsnull != extensions)
|
|
break;
|
|
}
|
|
|
|
if (cnt < variants)
|
|
{
|
|
aMimeType = plugins->mMimeTypeArray[cnt];
|
|
#ifdef NS_DEBUG
|
|
printf("found plugin via extension %s\n", ext);
|
|
#endif
|
|
break;
|
|
}
|
|
|
|
plugins = plugins->mNext;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// check to see if we've found a plugin that matches the mimetype
|
|
if (nsnull != plugins)
|
|
{
|
|
// check to see if the plugin has already been loaded (e.g. by a previous instance)
|
|
if (nsnull == plugins->mLibrary)
|
|
{
|
|
char path[2000];
|
|
|
|
PL_strcpy(path, mPluginPath);
|
|
PL_strcat(path, plugins->mName);
|
|
|
|
// load the plugin
|
|
plugins->mLibrary = LoadPluginLibrary(mPluginPath, path);
|
|
}
|
|
|
|
if (nsnull != plugins->mLibrary)
|
|
{
|
|
if (nsnull == plugins->mEntryPoint)
|
|
{
|
|
//create the plugin object
|
|
|
|
if (plugins->mFlags & NS_PLUGIN_FLAG_OLDSCHOOL)
|
|
{
|
|
// we have to load an old 4x style plugin
|
|
nsresult rv = ns4xPlugin::CreatePlugin(plugins->mLibrary, (nsIPlugin **)&plugins->mEntryPoint,
|
|
mServiceMgr);
|
|
}
|
|
else
|
|
{
|
|
// we have to load a new 5x style plugin
|
|
nsFactoryProc fact = (nsFactoryProc)PR_FindSymbol(plugins->mLibrary, "NSGetFactory");
|
|
|
|
if (nsnull != fact)
|
|
(fact)(mServiceMgr, kPluginCID, 0, 0, (nsIFactory**)&plugins->mEntryPoint);
|
|
|
|
// we only need to call this for 5x style plugins - CreatePlugin() handles this for
|
|
// 4x style plugins
|
|
if (nsnull != plugins->mEntryPoint)
|
|
plugins->mEntryPoint->Initialize();
|
|
}
|
|
}
|
|
|
|
if (nsnull != plugins->mEntryPoint)
|
|
{
|
|
nsIPluginInstance *instance;
|
|
|
|
//create an instance
|
|
|
|
if (NS_OK == plugins->mEntryPoint->CreateInstance(nsnull, kIPluginInstanceIID, (void **)&instance))
|
|
{
|
|
aOwner->SetInstance(instance);
|
|
|
|
nsPluginInstancePeerImpl *peer = new nsPluginInstancePeerImpl();
|
|
|
|
// set up the peer for the instance
|
|
peer->Initialize(aOwner, aMimeType); //this will not add a ref to the instance (or owner). MMP
|
|
|
|
// tell the plugin instance to initialize itself and pass in the peer.
|
|
|
|
instance->Initialize(peer);
|
|
NS_RELEASE(instance);
|
|
}
|
|
}
|
|
}
|
|
else
|
|
return NS_ERROR_UNEXPECTED; // LoadPluginLibrary failure
|
|
|
|
return NS_OK;
|
|
}
|
|
else
|
|
{
|
|
#ifdef NS_DEBUG
|
|
if ((nsnull != aURL) || (nsnull != aMimeType))
|
|
printf("unable to find plugin to handle %s\n", aMimeType ? aMimeType : "(mime type unspecified)");
|
|
#endif
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
}
|
|
|
|
#endif /* !XP_MAC */
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetPluginFactory(const char *aMimeType, nsIPlugin** aPlugin)
|
|
{
|
|
nsresult res = NS_ERROR_FAILURE;
|
|
*aPlugin = NULL;
|
|
|
|
// If plugins haven't been scanned yet, do so now.
|
|
if (mPlugins == NULL)
|
|
LoadPlugins();
|
|
|
|
// search the plugin list for the specified MIME type.
|
|
// TODO: should look at the MIME type array as well.
|
|
if (aMimeType != nsnull) {
|
|
nsPluginTag* pluginTag = mPlugins;
|
|
while (pluginTag != nsnull) {
|
|
if (::strcmp(aMimeType, pluginTag->mMimeType) == 0) {
|
|
nsIPlugin* plugin = pluginTag->mEntryPoint;
|
|
if (plugin == NULL) {
|
|
// need to get the plugin factory from this plugin.
|
|
nsFactoryProc nsGetFactory = (nsFactoryProc) PR_FindSymbol(pluginTag->mLibrary, "NSGetFactory");
|
|
if (nsGetFactory != NULL) {
|
|
res = nsGetFactory(mServiceMgr, kPluginCID, nsnull, nsnull, // XXX fix ClassName/ProgID
|
|
(nsIFactory**)&pluginTag->mEntryPoint);
|
|
plugin = pluginTag->mEntryPoint;
|
|
if (plugin != NULL)
|
|
plugin->Initialize();
|
|
}
|
|
}
|
|
if (plugin != NULL) {
|
|
*aPlugin = plugin;
|
|
plugin->AddRef();
|
|
res = NS_OK;
|
|
break;
|
|
}
|
|
}
|
|
pluginTag = pluginTag->mNext;
|
|
}
|
|
}
|
|
return res;
|
|
}
|
|
|
|
#ifdef XP_MAC
|
|
|
|
// excuse me while I try to rewrite this using XP code...
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::LoadPlugins()
|
|
{
|
|
do {
|
|
// 1. scan the plugins directory (where is it?) for eligible plugin libraries.
|
|
nsPluginsDir pluginsDir;
|
|
if (! pluginsDir.Valid())
|
|
break;
|
|
|
|
for (nsDirectoryIterator iter(pluginsDir); iter.Exists(); iter++) {
|
|
const nsFileSpec& file = iter;
|
|
if (pluginsDir.IsPluginFile(file)) {
|
|
nsPluginFile pluginFile(file);
|
|
// load the plugin's library so we can ask it some questions.
|
|
PRLibrary* pluginLibrary = NULL;
|
|
if (pluginFile.LoadPlugin(pluginLibrary) == NS_OK && pluginLibrary != NULL) {
|
|
// create a tag describing this plugin.
|
|
nsPluginTag* pluginTag = new nsPluginTag();
|
|
pluginTag->mNext = mPlugins;
|
|
mPlugins = pluginTag;
|
|
|
|
nsPluginInfo info = { sizeof(info) };
|
|
if (pluginFile.GetPluginInfo(info) == NS_OK) {
|
|
pluginTag->mName = info.fName;
|
|
pluginTag->mDescription = info.fDescription;
|
|
pluginTag->mMimeType = info.fMimeType;
|
|
pluginTag->mMimeDescription = info.fMimeDescription;
|
|
pluginTag->mExtensions = info.fExtensions;
|
|
pluginTag->mVariants = info.fVariantCount;
|
|
pluginTag->mMimeTypeArray = info.fMimeTypeArray;
|
|
pluginTag->mMimeDescriptionArray = info.fMimeDescriptionArray;
|
|
}
|
|
|
|
pluginTag->mLibrary = pluginLibrary;
|
|
pluginTag->mEntryPoint = NULL;
|
|
pluginTag->mFlags = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
mPluginsLoaded = PR_TRUE;
|
|
return NS_OK;
|
|
} while (0);
|
|
|
|
return NS_ERROR_FAILURE;
|
|
}
|
|
|
|
#else
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::LoadPlugins(void)
|
|
{
|
|
#ifdef XP_PC
|
|
long result;
|
|
HKEY keyloc;
|
|
DWORD type, pathlen;
|
|
char path[2000];
|
|
PRDir *dir = nsnull;
|
|
|
|
if (::GetModuleFileName(NULL, path, sizeof(path)) > 0)
|
|
{
|
|
pathlen = PL_strlen(path) - 1;
|
|
|
|
while (pathlen > 0)
|
|
{
|
|
if (path[pathlen] == '\\')
|
|
break;
|
|
|
|
pathlen--;
|
|
}
|
|
|
|
if (pathlen > 0)
|
|
{
|
|
PL_strcpy(&path[pathlen + 1], "plugins");
|
|
dir = PR_OpenDir(path);
|
|
}
|
|
}
|
|
|
|
if (nsnull == dir)
|
|
{
|
|
path[0] = 0;
|
|
|
|
result = ::RegOpenKeyEx(HKEY_CURRENT_USER,
|
|
"Software\\Netscape\\Netscape Navigator\\Main",
|
|
0, KEY_READ, &keyloc);
|
|
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
pathlen = sizeof(path);
|
|
|
|
result = ::RegQueryValueEx(keyloc, "Install Directory",
|
|
NULL, &type, (LPBYTE)&path, &pathlen);
|
|
|
|
if (result == ERROR_SUCCESS)
|
|
{
|
|
PL_strcat(path, "\\Program\\Plugins");
|
|
}
|
|
|
|
::RegCloseKey(keyloc);
|
|
}
|
|
|
|
dir = PR_OpenDir(path);
|
|
}
|
|
|
|
#ifdef NS_DEBUG
|
|
if (path[0] != 0)
|
|
printf("plugins at: %s\n", path);
|
|
#endif
|
|
|
|
if (nsnull != dir)
|
|
{
|
|
PRDirEntry *dent;
|
|
char *verbuf = NULL;
|
|
DWORD verbufsize = 0;
|
|
|
|
pathlen = PL_strlen(path);
|
|
mPluginPath = (char *)PR_Malloc(pathlen + 2);
|
|
|
|
if (nsnull != mPluginPath)
|
|
{
|
|
PL_strcpy(mPluginPath, path);
|
|
|
|
mPluginPath[pathlen] = '\\';
|
|
mPluginPath[pathlen + 1] = 0;
|
|
}
|
|
|
|
while (nsnull != mPlugins)
|
|
{
|
|
nsPluginTag *temp = mPlugins->mNext;
|
|
delete mPlugins;
|
|
mPlugins = temp;
|
|
}
|
|
|
|
while (dent = PR_ReadDir(dir, PR_SKIP_BOTH))
|
|
{
|
|
PRInt32 len = PL_strlen(dent->name);
|
|
|
|
if (len > 6) //np*.dll
|
|
{
|
|
if ((0 == stricmp(&dent->name[len - 4], ".dll")) && //ends in '.dll'
|
|
(0 == PL_strncasecmp(dent->name, "np", 2))) //starts with 'np'
|
|
{
|
|
PRLibrary *plugin;
|
|
|
|
PL_strcpy(path, mPluginPath);
|
|
PL_strcat(path, dent->name);
|
|
|
|
plugin = LoadPluginLibrary(mPluginPath, path);
|
|
|
|
if (NULL != plugin)
|
|
{
|
|
DWORD zerome, versionsize;
|
|
|
|
versionsize = ::GetFileVersionInfoSize(path, &zerome);
|
|
|
|
if (versionsize > 0)
|
|
{
|
|
if (versionsize > verbufsize)
|
|
{
|
|
if (nsnull != verbuf)
|
|
PR_Free(verbuf);
|
|
|
|
verbuf = (char *)PR_Malloc(versionsize);
|
|
verbufsize = versionsize;
|
|
}
|
|
|
|
if ((nsnull != verbuf) && ::GetFileVersionInfo(path, NULL, verbufsize, verbuf))
|
|
{
|
|
char *buf = NULL;
|
|
UINT blen;
|
|
nsPluginTag *plugintag;
|
|
PRBool completetag = PR_FALSE;
|
|
PRInt32 variants;
|
|
|
|
plugintag = new nsPluginTag();
|
|
|
|
while (nsnull != plugintag)
|
|
{
|
|
plugintag->mName = (char *)PR_Malloc(PL_strlen(dent->name) + 1);
|
|
|
|
if (nsnull == plugintag->mName)
|
|
break;
|
|
else
|
|
PL_strcpy(plugintag->mName, dent->name);
|
|
|
|
::VerQueryValue(verbuf,
|
|
TEXT("\\StringFileInfo\\040904E4\\FileDescription"),
|
|
(void **)&buf, &blen);
|
|
|
|
if (NULL == buf)
|
|
break;
|
|
else
|
|
{
|
|
plugintag->mDescription = (char *)PR_Malloc(blen + 1);
|
|
|
|
if (nsnull == plugintag->mDescription)
|
|
break;
|
|
else
|
|
PL_strcpy(plugintag->mDescription, buf);
|
|
}
|
|
|
|
::VerQueryValue(verbuf,
|
|
TEXT("\\StringFileInfo\\040904E4\\MIMEType"),
|
|
(void **)&buf, &blen);
|
|
|
|
if (NULL == buf)
|
|
break;
|
|
else
|
|
{
|
|
plugintag->mMimeType = (char *)PR_Malloc(blen + 1);
|
|
|
|
if (nsnull == plugintag->mMimeType)
|
|
break;
|
|
else
|
|
PL_strcpy(plugintag->mMimeType, buf);
|
|
|
|
buf = plugintag->mMimeType;
|
|
|
|
variants = 1;
|
|
|
|
while (*buf)
|
|
{
|
|
if (*buf == '|')
|
|
variants++;
|
|
|
|
buf++;
|
|
}
|
|
|
|
plugintag->mVariants = variants;
|
|
|
|
plugintag->mMimeTypeArray = (char **)PR_Malloc(variants * sizeof(char *));
|
|
|
|
if (nsnull == plugintag->mMimeTypeArray)
|
|
break;
|
|
else
|
|
{
|
|
variants = 0;
|
|
|
|
plugintag->mMimeTypeArray[variants++] = plugintag->mMimeType;
|
|
|
|
buf = plugintag->mMimeType;
|
|
|
|
while (*buf)
|
|
{
|
|
if (*buf == '|')
|
|
{
|
|
plugintag->mMimeTypeArray[variants++] = buf + 1;
|
|
*buf = 0;
|
|
}
|
|
|
|
buf++;
|
|
}
|
|
}
|
|
}
|
|
|
|
::VerQueryValue(verbuf,
|
|
TEXT("\\StringFileInfo\\040904E4\\FileOpenName"),
|
|
(void **)&buf, &blen);
|
|
|
|
if (NULL == buf)
|
|
break;
|
|
else
|
|
{
|
|
plugintag->mMimeDescription = (char *)PR_Malloc(blen + 1);
|
|
|
|
if (nsnull == plugintag->mMimeDescription)
|
|
break;
|
|
else
|
|
PL_strcpy(plugintag->mMimeDescription, buf);
|
|
|
|
buf = plugintag->mMimeDescription;
|
|
|
|
variants = 1;
|
|
|
|
while (*buf)
|
|
{
|
|
if (*buf == '|')
|
|
variants++;
|
|
|
|
buf++;
|
|
}
|
|
|
|
if (variants != plugintag->mVariants)
|
|
break;
|
|
|
|
plugintag->mMimeDescriptionArray = (char **)PR_Malloc(variants * sizeof(char *));
|
|
|
|
if (nsnull == plugintag->mMimeDescriptionArray)
|
|
break;
|
|
else
|
|
{
|
|
variants = 0;
|
|
|
|
plugintag->mMimeDescriptionArray[variants++] = plugintag->mMimeDescription;
|
|
|
|
buf = plugintag->mMimeDescription;
|
|
|
|
while (*buf)
|
|
{
|
|
if (*buf == '|')
|
|
{
|
|
plugintag->mMimeDescriptionArray[variants++] = buf + 1;
|
|
*buf = 0;
|
|
}
|
|
|
|
buf++;
|
|
}
|
|
}
|
|
}
|
|
|
|
::VerQueryValue(verbuf,
|
|
TEXT("\\StringFileInfo\\040904E4\\FileExtents"),
|
|
(void **)&buf, &blen);
|
|
|
|
if (NULL == buf)
|
|
break;
|
|
else
|
|
{
|
|
plugintag->mExtensions = (char *)PR_Malloc(blen + 1);
|
|
|
|
if (nsnull == plugintag->mExtensions)
|
|
break;
|
|
else
|
|
PL_strcpy(plugintag->mExtensions, buf);
|
|
|
|
buf = plugintag->mExtensions;
|
|
|
|
variants = 1;
|
|
|
|
while (*buf)
|
|
{
|
|
if (*buf == '|')
|
|
variants++;
|
|
|
|
buf++;
|
|
}
|
|
|
|
if (variants != plugintag->mVariants)
|
|
break;
|
|
|
|
plugintag->mExtensionsArray = (char **)PR_Malloc(variants * sizeof(char *));
|
|
|
|
if (nsnull == plugintag->mExtensionsArray)
|
|
break;
|
|
else
|
|
{
|
|
variants = 0;
|
|
|
|
plugintag->mExtensionsArray[variants++] = plugintag->mExtensions;
|
|
|
|
buf = plugintag->mExtensions;
|
|
|
|
while (*buf)
|
|
{
|
|
if (*buf == '|')
|
|
{
|
|
plugintag->mExtensionsArray[variants++] = buf + 1;
|
|
*buf = 0;
|
|
}
|
|
|
|
buf++;
|
|
}
|
|
}
|
|
}
|
|
|
|
completetag = PR_TRUE;
|
|
break;
|
|
}
|
|
|
|
if (PR_FALSE == completetag)
|
|
delete plugintag;
|
|
else
|
|
{
|
|
if (nsnull == PR_FindSymbol(plugin, "NSGetFactory"))
|
|
plugintag->mFlags |= NS_PLUGIN_FLAG_OLDSCHOOL;
|
|
|
|
#ifdef NS_DEBUG
|
|
printf("plugin %s added to list %s\n", plugintag->mName, (plugintag->mFlags & NS_PLUGIN_FLAG_OLDSCHOOL) ? "(old school)" : "");
|
|
#endif
|
|
plugintag->mNext = mPlugins;
|
|
mPlugins = plugintag;
|
|
}
|
|
}
|
|
}
|
|
|
|
PR_UnloadLibrary(plugin);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nsnull != verbuf)
|
|
PR_Free(verbuf);
|
|
|
|
PR_CloseDir(dir);
|
|
}
|
|
|
|
#else
|
|
#ifdef NS_DEBUG
|
|
printf("Don't know how to locate plugins directory on Unix yet...\n");
|
|
#endif
|
|
#endif
|
|
|
|
mPluginsLoaded = PR_TRUE;
|
|
|
|
return NS_OK;
|
|
}
|
|
|
|
#endif /* !XP_MAC */
|
|
|
|
// private methods
|
|
|
|
PRLibrary* nsPluginHostImpl::LoadPluginLibrary(const nsFileSpec &pluginSpec)
|
|
{
|
|
PRLibrary* plugin = NULL;
|
|
|
|
#ifdef XP_PC
|
|
plugin = PR_LoadLibrary((const char*)pluginSpec);
|
|
#endif
|
|
|
|
#ifdef XP_MAC
|
|
char* pluginName = pluginSpec.GetLeafName();
|
|
if (pluginName != NULL) {
|
|
plugin = PR_LoadLibrary(pluginName);
|
|
delete[] pluginName;
|
|
}
|
|
#endif
|
|
|
|
return plugin;
|
|
}
|
|
|
|
|
|
PRLibrary* nsPluginHostImpl::LoadPluginLibrary(const char* pluginPath, const char* path)
|
|
{
|
|
#ifdef XP_PC
|
|
BOOL restoreOrigDir = FALSE;
|
|
char aOrigDir[MAX_PATH + 1];
|
|
DWORD dwCheck = ::GetCurrentDirectory(sizeof(aOrigDir), aOrigDir);
|
|
PR_ASSERT(dwCheck <= MAX_PATH + 1);
|
|
|
|
if (dwCheck <= MAX_PATH + 1)
|
|
{
|
|
restoreOrigDir = ::SetCurrentDirectory(pluginPath);
|
|
PR_ASSERT(restoreOrigDir);
|
|
}
|
|
|
|
PRLibrary* plugin = PR_LoadLibrary(path);
|
|
|
|
if (restoreOrigDir)
|
|
{
|
|
BOOL bCheck = ::SetCurrentDirectory(aOrigDir);
|
|
PR_ASSERT(bCheck);
|
|
}
|
|
|
|
return plugin;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
|
|
/* Called by GetURL and PostURL */
|
|
|
|
#ifdef NEW_PLUGIN_STREAM_API
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: NewPluginURLStream(const nsString& aURL,
|
|
nsIPluginInstance *aInstance,
|
|
nsIPluginStreamListener* aListener)
|
|
{
|
|
nsIURL *url;
|
|
nsPluginStreamListenerPeer *listenerPeer = (nsPluginStreamListenerPeer *)new nsPluginStreamListenerPeer();
|
|
if (listenerPeer == NULL)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
nsresult rv;
|
|
|
|
if (aURL.Length() <= 0)
|
|
return NS_OK;
|
|
|
|
rv = NS_NewURL(&url, aURL);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
rv = listenerPeer->Initialize(url, aInstance, aListener);
|
|
|
|
if (NS_OK == rv) {
|
|
rv = NS_OpenURL(url, listenerPeer);
|
|
}
|
|
|
|
NS_RELEASE(url);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
#else
|
|
|
|
/* Called by GetURL and PostURL */
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl :: NewPluginURLStream(const nsString& aURL,
|
|
nsIPluginInstance *aInstance,
|
|
void *aNotifyData)
|
|
{
|
|
nsIURL *url;
|
|
nsPluginStreamListenerPeer *listener = (nsPluginStreamListenerPeer *)new nsPluginStreamListenerPeer();
|
|
if (listener == NULL)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
nsresult rv;
|
|
|
|
if (aURL.Length() <= 0)
|
|
return NS_OK;
|
|
|
|
rv = NS_NewURL(&url, aURL);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
rv = listener->Initialize(url, aInstance, aNotifyData);
|
|
|
|
if (NS_OK == rv) {
|
|
rv = NS_OpenURL(url, listener);
|
|
}
|
|
|
|
NS_RELEASE(url);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
#endif
|
|
|
|
/* Called by InstantiateEmbededPlugin() */
|
|
|
|
nsresult nsPluginHostImpl :: NewEmbededPluginStream(const nsString& aURL,
|
|
nsIPluginInstanceOwner *aOwner,
|
|
nsIPluginInstance* aInstance)
|
|
{
|
|
nsIURL *url;
|
|
nsPluginStreamListenerPeer *listener = (nsPluginStreamListenerPeer *)new nsPluginStreamListenerPeer();
|
|
nsresult rv;
|
|
|
|
if (aURL.Length() <= 0)
|
|
return NS_OK;
|
|
|
|
rv = NS_NewURL(&url, aURL);
|
|
|
|
if (NS_OK == rv)
|
|
{
|
|
// if we have an instance, everything has been set up
|
|
// if we only have an owner, then we need to pass it in
|
|
// so the listener can set up the instance later after
|
|
// we've determined the mimetype of the stream
|
|
if(aInstance != nsnull)
|
|
rv = listener->InitializeEmbeded(url, aInstance);
|
|
else if(aOwner != nsnull)
|
|
rv = listener->InitializeEmbeded(url, nsnull, aOwner, (nsIPluginHost *)this);
|
|
else
|
|
rv = NS_ERROR_ILLEGAL_VALUE;
|
|
|
|
if (NS_OK == rv) {
|
|
rv = NS_OpenURL(url, listener);
|
|
}
|
|
|
|
NS_RELEASE(url);
|
|
}
|
|
|
|
return rv;
|
|
}
|
|
|
|
/* Called by InstantiateFullPagePlugin() */
|
|
|
|
nsresult nsPluginHostImpl :: NewFullPagePluginStream(nsIStreamListener *&aStreamListener,
|
|
nsIPluginInstance *aInstance)
|
|
{
|
|
nsPluginStreamListenerPeer *listener = (nsPluginStreamListenerPeer *)new nsPluginStreamListenerPeer();
|
|
nsresult rv;
|
|
|
|
rv = listener->InitializeFullPage(aInstance);
|
|
|
|
aStreamListener = (nsIStreamListener *)listener;
|
|
NS_IF_ADDREF(listener);
|
|
|
|
return rv;
|
|
}
|
|
|
|
// nsIFactory interface
|
|
|
|
nsresult nsPluginHostImpl::CreateInstance(nsISupports *aOuter,
|
|
const nsIID &aIID,
|
|
void **aResult)
|
|
{
|
|
if (aResult == NULL)
|
|
return NS_ERROR_NULL_POINTER;
|
|
|
|
nsISupports *inst = nsnull;
|
|
|
|
#ifndef NEW_PLUGIN_STREAM_API
|
|
if (aIID.Equals(kIPluginStreamPeerIID))
|
|
inst = (nsISupports *)(nsIPluginStreamPeer *)new nsPluginStreamPeer();
|
|
#endif
|
|
|
|
if (inst == NULL)
|
|
return NS_ERROR_OUT_OF_MEMORY;
|
|
|
|
nsresult res = inst->QueryInterface(aIID, aResult);
|
|
|
|
if (res != NS_OK) {
|
|
// We didn't get the right interface, so clean up
|
|
delete inst;
|
|
}
|
|
|
|
return res;
|
|
}
|
|
|
|
nsresult nsPluginHostImpl :: LockFactory(PRBool aLock)
|
|
{
|
|
// Not implemented in simplest case.
|
|
return NS_OK;
|
|
}
|
|
|
|
// nsIFileUtilities interface
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetProgramPath(const char* *result)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::GetTempDirPath(const char* *result)
|
|
{
|
|
return NS_OK;
|
|
}
|
|
|
|
NS_IMETHODIMP nsPluginHostImpl::NewTempFileName(const char* prefix, PRUint32 bufLen, char* resultBuf)
|
|
{
|
|
return NS_OK;
|
|
}
|