() {
@Override
public Boolean run() {
boolean res = false;
dynLookup.claimAllLinkPermission();
try {
final int variants = GLNameResolver.getFuncNamePermutationNumber(tmpBase);
for(int i = 0; !res && i < variants; i++) {
final String tmp = GLNameResolver.getFuncNamePermutation(tmpBase, i);
try {
res = dynLookup.isFunctionAvailable(tmp);
} catch (final Exception e) { }
}
} finally {
dynLookup.releaseAllLinkPermission();
}
return Boolean.valueOf(res);
} } ).booleanValue();
}
@Override
public final boolean isExtensionAvailable(final String glExtensionName) {
if(null!=extensionAvailability) {
return extensionAvailability.isExtensionAvailable(mapToRealGLExtensionName(glExtensionName));
}
return false;
}
@Override
public final int getPlatformExtensionCount() {
return null != extensionAvailability ? extensionAvailability.getPlatformExtensionCount() : 0;
}
@Override
public final String getPlatformExtensionsString() {
if(null!=extensionAvailability) {
return extensionAvailability.getPlatformExtensionsString();
}
return null;
}
@Override
public final int getGLExtensionCount() {
return null != extensionAvailability ? extensionAvailability.getGLExtensionCount() : 0;
}
@Override
public final String getGLExtensionsString() {
if(null!=extensionAvailability) {
return extensionAvailability.getGLExtensionsString();
}
return null;
}
public final boolean isExtensionCacheInitialized() {
if(null!=extensionAvailability) {
return extensionAvailability.isInitialized();
}
return false;
}
protected static String getContextFQN(final AbstractGraphicsDevice device, final int major, final int minor, int ctxProfileBits) {
// remove non-key values
ctxProfileBits &= CTX_IMPL_CACHE_MASK;
return device.getUniqueID() + "-" + toHexString(composeBits(major, minor, ctxProfileBits));
}
protected final String getContextFQN() {
return contextFQN;
}
@Override
public int getDefaultPixelDataType() {
evalPixelDataType();
return pixelDataType;
}
@Override
public int getDefaultPixelDataFormat() {
evalPixelDataType();
return pixelDataFormat;
}
private final void evalPixelDataType() {
if(!pixelDataEvaluated) { // only valid while context is made current
boolean ok = false;
/* if(isGL2GL3() && 3 == components) {
pixelDataInternalFormat=GL.GL_RGB;
pixelDataFormat=GL.GL_RGB;
pixelDataType = GL.GL_UNSIGNED_BYTE;
ok = true;
} else */ if( isGLES2Compatible() || isExtensionAvailable(GLExtensions.OES_read_format) ) {
final int[] glImplColorReadVals = new int[] { 0, 0 };
gl.glGetIntegerv(GL.GL_IMPLEMENTATION_COLOR_READ_FORMAT, glImplColorReadVals, 0);
gl.glGetIntegerv(GL.GL_IMPLEMENTATION_COLOR_READ_TYPE, glImplColorReadVals, 1);
// pixelDataInternalFormat = (4 == components) ? GL.GL_RGBA : GL.GL_RGB;
pixelDataFormat = glImplColorReadVals[0];
pixelDataType = glImplColorReadVals[1];
ok = 0 != pixelDataFormat && 0 != pixelDataType;
}
if( !ok ) {
// RGBA read is safe for all GL profiles
// pixelDataInternalFormat = (4 == components) ? GL.GL_RGBA : GL.GL_RGB;
pixelDataFormat=GL.GL_RGBA;
pixelDataType = GL.GL_UNSIGNED_BYTE;
}
// TODO: Consider:
// return gl.isGL2GL3()?GL2GL3.GL_UNSIGNED_INT_8_8_8_8_REV:GL.GL_UNSIGNED_SHORT_5_5_5_1;
pixelDataEvaluated = true;
}
}
//----------------------------------------------------------------------
// SwapBuffer
@Override
public final boolean setSwapInterval(final int interval) throws GLException {
validateCurrent();
return setSwapIntervalNC(interval);
}
protected final boolean setSwapIntervalNC(final int interval) throws GLException {
if( !drawableRetargeted ||
!hasRendererQuirk(GLRendererQuirks.NoSetSwapIntervalPostRetarget)
)
{
final Integer usedInterval = setSwapIntervalImpl2(interval);
if( null != usedInterval ) {
currentSwapInterval = usedInterval.intValue();
return true;
}
}
return false;
}
protected abstract Integer setSwapIntervalImpl2(final int interval);
@Override
public final int getSwapInterval() {
return currentSwapInterval;
}
@Override
protected final void setDefaultSwapInterval() {
currentSwapInterval = 0;
setSwapIntervalNC(1);
}
//----------------------------------------------------------------------
// Helpers for buffer object optimizations
public final GLBufferObjectTracker getBufferObjectTracker() {
return bufferObjectTracker;
}
public final GLBufferStateTracker getBufferStateTracker() {
return bufferStateTracker;
}
public final GLStateTracker getGLStateTracker() {
return glStateTracker;
}
//---------------------------------------------------------------------------
// Helpers for context optimization where the last context is left
// current on the OpenGL worker thread
//
/**
* Returns true if the given thread is owner, otherwise false.
*
* Method exists merely for code validation of {@link #isCurrent()}.
*
*/
public final boolean isOwner(final Thread thread) {
return lock.isOwner(thread);
}
/**
* Returns true if there are other threads waiting for this GLContext to {@link #makeCurrent()}, otherwise false.
*
* Since method does not perform any synchronization, accurate result are returned if lock is hold - only.
*
*/
public final boolean hasWaiters() {
return lock.getQueueLength()>0;
}
/**
* Returns the number of hold locks. See {@link RecursiveLock#getHoldCount()} for semantics.
*
* Since method does not perform any synchronization, accurate result are returned if lock is hold - only.
*
*/
public final int getLockCount() {
return lock.getHoldCount();
}
//---------------------------------------------------------------------------
// Special FBO hook
//
/**
* Tracks {@link GL#GL_FRAMEBUFFER}, {@link GL2GL3#GL_DRAW_FRAMEBUFFER} and {@link GL2GL3#GL_READ_FRAMEBUFFER}
* to be returned via {@link #getBoundFramebuffer(int)}.
*
* Invoked by {@link GL#glBindFramebuffer(int, int)}.
*
* Assumes valid framebufferName range of [0..{@link Integer#MAX_VALUE}]
*
* Does not throw an exception if target is unknown or framebufferName invalid.
*/
public final void setBoundFramebuffer(final int target, final int framebufferName) {
if(0 > framebufferName) {
return; // ignore invalid name
}
switch(target) {
case GL.GL_FRAMEBUFFER:
case GL.GL_DRAW_FRAMEBUFFER:
boundFBOTarget[0] = framebufferName; // draw
break;
case GL.GL_READ_FRAMEBUFFER:
boundFBOTarget[1] = framebufferName; // read
break;
default: // ignore untracked target
}
}
@Override
public final int getBoundFramebuffer(final int target) {
switch(target) {
case GL.GL_FRAMEBUFFER:
case GL.GL_DRAW_FRAMEBUFFER:
return boundFBOTarget[0]; // draw
case GL.GL_READ_FRAMEBUFFER:
return boundFBOTarget[1]; // read
default:
throw new InternalError("Invalid FBO target name: "+toHexString(target));
}
}
@Override
public final int getDefaultDrawFramebuffer() { return drawable.getDefaultDrawFramebuffer(); }
@Override
public final int getDefaultReadFramebuffer() { return drawable.getDefaultReadFramebuffer(); }
@Override
public final int getDefaultDrawBuffer() { return drawable.getDefaultDrawBuffer(gl); }
@Override
public final int getDefaultReadBuffer() { return drawable.getDefaultReadBuffer(gl, drawableRead != drawable); }
//---------------------------------------------------------------------------
// GL_ARB_debug_output, GL_AMD_debug_output helpers
//
@Override
public final String getGLDebugMessageExtension() {
return glDebugHandler.getExtension();
}
@Override
public final boolean isGLDebugMessageEnabled() {
return glDebugHandler.isEnabled();
}
@Override
public final int getContextCreationFlags() {
return additionalCtxCreationFlags;
}
@Override
public final void setContextCreationFlags(final int flags) {
if(!isCreated()) {
additionalCtxCreationFlags = flags & GLContext.CTX_OPTION_DEBUG;
}
}
@Override
public final boolean isGLDebugSynchronous() { return glDebugHandler.isSynchronous(); }
@Override
public final void setGLDebugSynchronous(final boolean synchronous) {
glDebugHandler.setSynchronous(synchronous);
}
@Override
public final void enableGLDebugMessage(final boolean enable) throws GLException {
if(!isCreated()) {
if(enable) {
additionalCtxCreationFlags |= GLContext.CTX_OPTION_DEBUG;
} else {
additionalCtxCreationFlags &= ~GLContext.CTX_OPTION_DEBUG;
}
} else if(0 != (additionalCtxCreationFlags & GLContext.CTX_OPTION_DEBUG) &&
null != getGLDebugMessageExtension()) {
glDebugHandler.enable(enable);
}
}
@Override
public final void addGLDebugListener(final GLDebugListener listener) {
glDebugHandler.addListener(listener);
}
@Override
public final void removeGLDebugListener(final GLDebugListener listener) {
glDebugHandler.removeListener(listener);
}
@Override
public final void glDebugMessageControl(final int source, final int type, final int severity, final int count, final IntBuffer ids, final boolean enabled) {
if(glDebugHandler.isExtensionKHRARB()) {
gl.getGL2ES2().glDebugMessageControl(source, type, severity, count, ids, enabled);
} else if(glDebugHandler.isExtensionAMD()) {
gl.getGL2GL3().glDebugMessageEnableAMD(GLDebugMessage.translateARB2AMDCategory(source, type), severity, count, ids, enabled);
}
}
@Override
public final void glDebugMessageControl(final int source, final int type, final int severity, final int count, final int[] ids, final int ids_offset, final boolean enabled) {
if(glDebugHandler.isExtensionKHRARB()) {
gl.getGL2ES2().glDebugMessageControl(source, type, severity, count, ids, ids_offset, enabled);
} else if(glDebugHandler.isExtensionAMD()) {
gl.getGL2GL3().glDebugMessageEnableAMD(GLDebugMessage.translateARB2AMDCategory(source, type), severity, count, ids, ids_offset, enabled);
}
}
@Override
public final void glDebugMessageInsert(final int source, final int type, final int id, final int severity, final String buf) {
final int len = (null != buf) ? buf.length() : 0;
if(glDebugHandler.isExtensionKHRARB()) {
gl.getGL2ES2().glDebugMessageInsert(source, type, id, severity, len, buf);
} else if(glDebugHandler.isExtensionAMD()) {
gl.getGL2GL3().glDebugMessageInsertAMD(GLDebugMessage.translateARB2AMDCategory(source, type), severity, id, len, buf);
}
}
/* pp */ final String glGetStringiInt(final int name, final int index) {
if( 0 == glGetStringiPtr ) {
// should not be reached, since initGLRendererAndGLVersionStrings(..)'s failure should abort caller!
throw new InternalError("Not initialized: glGetStringiPtr "+toHexString(glGetStringiPtr));
}
return glGetStringiInt(name, index, glGetStringiPtr);
}
/* pp */ final boolean has_glGetStringiInt() { return 0 != glGetStringiPtr; }
/* pp */ final String glGetStringInt(final int name) {
if( 0 == glGetStringPtr ) {
// should not be reached, since initGLRendererAndGLVersionStrings(..)'s failure should abort caller!
throw new InternalError("Not initialized: glGetStringPtr "+toHexString(glGetStringPtr));
}
return glGetStringInt(name, glGetStringPtr);
}
/* pp */ final void glGetIntegervInt(final int pname, final int[] params, final int params_offset) {
if( 0 == glGetIntegervPtr ) {
// should not be reached, since initGLRendererAndGLVersionStrings(..)'s failure should abort caller!
throw new InternalError("Not initialized: glGetIntegerv "+toHexString(glGetIntegervPtr));
}
glGetIntegervInt(pname, params, params_offset, glGetIntegervPtr);
}
/**
* Internal bootstraping glGetString(GL_RENDERER).
*
* Entry point to C language function: const GLubyte * {@native glGetStringi}(GLenum name, GLuint index)
Part of GL_ES_VERSION_3_0, GL_VERSION_3_0
*
**/
private static native String glGetStringiInt(int name, int index, long procAddress);
/**
* Internal bootstraping glGetString(GL_RENDERER).
*
* Entry point to C language function: const GLubyte * {@native glGetString}(GLenum name)
Part of GL_ES_VERSION_2_0, GL_VERSION_ES_CL_CM, GL_VERSION_1_0
*
*/
private static native String glGetStringInt(int name, long procAddress);
/** Internal bootstraping glGetIntegerv(..) for version */
private static native void glGetIntegervInt(int pname, int[] params, int params_offset, long procAddress);
}
(out_pipe_name);
PLUGIN_DEBUG ("ITNP_New: deleted input fifo: %s\n", in_pipe_name);
cleanup_out_pipe_name:
g_free (out_pipe_name);
out_pipe_name = NULL;
// cleanup_in_pipe:
// Delete input pipe.
PLUGIN_DEBUG ("ITNP_New: deleting output fifo: %s\n", out_pipe_name);
unlink (in_pipe_name);
PLUGIN_DEBUG ("ITNP_New: deleted output fifo: %s\n", out_pipe_name);
cleanup_in_pipe_name:
g_free (in_pipe_name);
in_pipe_name = NULL;
done:
// Now other threads may re-enter.. unlock the mutex
g_mutex_unlock(vm_start_mutex);
}
NPError
ITNP_GetValue (NPP instance, NPPVariable variable, void* value)
{
PLUGIN_DEBUG ("ITNP_GetValue\n");
NPError np_error = NPERR_NO_ERROR;
switch (variable)
{
// This plugin needs XEmbed support.
case NPPVpluginNeedsXEmbed:
{
PLUGIN_DEBUG ("ITNP_GetValue: returning TRUE for NeedsXEmbed.\n");
bool* bool_value = (bool*) value;
*bool_value = true;
}
break;
case NPPVpluginScriptableNPObject:
{
*(NPObject **)value = get_scriptable_object(instance);
}
break;
default:
PLUGIN_ERROR ("Unknown plugin value requested.");
np_error = NPERR_GENERIC_ERROR;
break;
}
PLUGIN_DEBUG ("ITNP_GetValue return\n");
return np_error;
}
NPError
ITNP_Destroy (NPP instance, NPSavedData** save)
{
PLUGIN_DEBUG ("ITNP_Destroy %p\n", instance);
ITNPPluginData* data = (ITNPPluginData*) instance->pdata;
int id = get_id_from_instance(instance);
// Let Java know that this applet needs to be destroyed
gchar* msg = (gchar*) g_malloc(512*sizeof(gchar)); // 512 is more than enough. We need < 100
g_sprintf(msg, "instance %d destroy", id);
plugin_send_message_to_appletviewer(msg);
g_free(msg);
msg = NULL;
if (data)
{
// Free plugin data.
plugin_data_destroy (instance);
}
g_hash_table_remove(instance_to_id_map, instance);
g_hash_table_remove(id_to_instance_map, GINT_TO_POINTER(id));
IcedTeaPluginUtilities::invalidateInstance(instance);
PLUGIN_DEBUG ("ITNP_Destroy return\n");
return NPERR_NO_ERROR;
}
NPError
ITNP_SetWindow (NPP instance, NPWindow* window)
{
PLUGIN_DEBUG ("ITNP_SetWindow\n");
if (instance == NULL)
{
PLUGIN_ERROR ("Invalid instance.");
return NPERR_INVALID_INSTANCE_ERROR;
}
gpointer id_ptr = g_hash_table_lookup(instance_to_id_map, instance);
gint id = 0;
if (id_ptr)
{
id = GPOINTER_TO_INT(id_ptr);
}
ITNPPluginData* data = (ITNPPluginData*) instance->pdata;
// Simply return if we receive a NULL window.
if ((window == NULL) || (window->window == NULL))
{
PLUGIN_DEBUG ("ITNP_SetWindow: got NULL window.\n");
return NPERR_NO_ERROR;
}
if (data->window_handle)
{
// The window already exists.
if (data->window_handle == window->window)
{
// The parent window is the same as in previous calls.
PLUGIN_DEBUG ("ITNP_SetWindow: window already exists.\n");
// Critical region. Read data->appletviewer_mutex and send
// a message to the appletviewer.
g_mutex_lock (data->appletviewer_mutex);
if (jvm_up)
{
gboolean dim_changed = FALSE;
// The window is the same as it was for the last
// SetWindow call.
if (window->width != data->window_width)
{
PLUGIN_DEBUG ("ITNP_SetWindow: window width changed.\n");
// The width of the plugin window has changed.
// Store the new width.
data->window_width = window->width;
dim_changed = TRUE;
}
if (window->height != data->window_height)
{
PLUGIN_DEBUG ("ITNP_SetWindow: window height changed.\n");
// The height of the plugin window has changed.
// Store the new height.
data->window_height = window->height;
dim_changed = TRUE;
}
if (dim_changed) {
gchar* message = g_strdup_printf ("instance %d width %d height %d",
id, window->width, window->height);
plugin_send_message_to_appletviewer (message);
g_free (message);
message = NULL;
}
}
else
{
// The appletviewer is not running.
PLUGIN_DEBUG ("ITNP_SetWindow: appletviewer is not running.\n");
}
g_mutex_unlock (data->appletviewer_mutex);
}
else
{
// The parent window has changed. This branch does run but
// doing nothing in response seems to be sufficient.
PLUGIN_DEBUG ("ITNP_SetWindow: parent window changed.\n");
}
}
else
{
// Else this is initialization
PLUGIN_DEBUG ("ITNP_SetWindow: setting window.\n");
// Critical region. Send messages to appletviewer.
g_mutex_lock (data->appletviewer_mutex);
// Store the window handle and dimensions
data->window_handle = window->window;
data->window_width = window->width;
data->window_height = window->height;
// Now we have everything. Send this data to the Java side
plugin_send_initialization_message(
data->instance_id, (gulong) data->window_handle,
data->window_width, data->window_height, data->parameters_string);
g_mutex_unlock (data->appletviewer_mutex);
}
PLUGIN_DEBUG ("ITNP_SetWindow return\n");
return NPERR_NO_ERROR;
}
NPError
ITNP_NewStream (NPP instance, NPMIMEType type, NPStream* stream,
NPBool seekable, uint16_t* stype)
{
PLUGIN_DEBUG ("ITNP_NewStream\n");
PLUGIN_DEBUG ("ITNP_NewStream return\n");
return NPERR_GENERIC_ERROR;
}
void
ITNP_StreamAsFile (NPP instance, NPStream* stream, const char* filename)
{
PLUGIN_DEBUG ("ITNP_StreamAsFile\n");
PLUGIN_DEBUG ("ITNP_StreamAsFile return\n");
}
NPError
ITNP_DestroyStream (NPP instance, NPStream* stream, NPReason reason)
{
PLUGIN_DEBUG ("ITNP_DestroyStream\n");
PLUGIN_DEBUG ("ITNP_DestroyStream return\n");
return NPERR_NO_ERROR;
}
int32_t
ITNP_WriteReady (NPP instance, NPStream* stream)
{
PLUGIN_DEBUG ("ITNP_WriteReady\n");
PLUGIN_DEBUG ("ITNP_WriteReady return\n");
return 0;
}
int32_t
ITNP_Write (NPP instance, NPStream* stream, int32_t offset, int32_t len,
void* buffer)
{
PLUGIN_DEBUG ("ITNP_Write\n");
PLUGIN_DEBUG ("ITNP_Write return\n");
return 0;
}
void
ITNP_Print (NPP instance, NPPrint* platformPrint)
{
PLUGIN_DEBUG ("ITNP_Print\n");
PLUGIN_DEBUG ("ITNP_Print return\n");
}
int16_t
ITNP_HandleEvent (NPP instance, void* event)
{
PLUGIN_DEBUG ("ITNP_HandleEvent\n");
PLUGIN_DEBUG ("ITNP_HandleEvent return\n");
return 0;
}
void
ITNP_URLNotify (NPP instance, const char* url, NPReason reason,
void* notifyData)
{
PLUGIN_DEBUG ("ITNP_URLNotify\n");
PLUGIN_DEBUG ("ITNP_URLNotify return\n");
}
NPError
get_cookie_info(const char* siteAddr, char** cookieString, uint32_t* len)
{
// Only attempt to perform this operation if there is a valid plugin instance
if (g_hash_table_size(instance_to_id_map) <= 0)
{
return NPERR_GENERIC_ERROR;
}
// getvalueforurl needs an NPP instance. Quite frankly, there is no easy way
// to know which instance needs the information, as applets on Java side can
// be multi-threaded and the thread making a proxy.cookie request cannot be
// easily tracked.
// Fortunately, XULRunner does not care about the instance as long as it is
// valid. So we just pick the first valid one and use it. Proxy/Cookie
// information is not instance specific anyway, it is URL specific.
if (browser_functions.getvalueforurl)
{
gpointer instance=getFirstInTableInstance(instance_to_id_map);
return browser_functions.getvalueforurl((NPP) instance, NPNURLVCookie, siteAddr, cookieString, len);
} else
{
return NPERR_GENERIC_ERROR;
}
return NPERR_NO_ERROR;
}
static NPError
set_cookie_info(const char* siteAddr, const char* cookieString, uint32_t len)
{
// Only attempt to perform this operation if there is a valid plugin instance
if (g_hash_table_size(instance_to_id_map) > 0 && browser_functions.getvalueforurl)
{
// We arbitrarily use the first valid instance we can grab
// For an explanation of the logic behind this, see get_cookie_info
gpointer instance = getFirstInTableInstance(instance_to_id_map);
return browser_functions.setvalueforurl((NPP) instance, NPNURLVCookie, siteAddr, cookieString, len);
}
return NPERR_GENERIC_ERROR;;
}
// HELPER FUNCTIONS
static void
plugin_data_new (ITNPPluginData** data)
{
PLUGIN_DEBUG ("plugin_data_new\n");
*data = (ITNPPluginData*)
(*browser_functions.memalloc) (sizeof (struct ITNPPluginData));
// appletviewer_alive is false until the applet viewer is spawned.
if (*data)
memset (*data, 0, sizeof (struct ITNPPluginData));
PLUGIN_DEBUG ("plugin_data_new return\n");
}
// Documentbase retrieval. This function gets the current document's
// documentbase. This function relies on browser-private data so it
// will only work when the plugin is loaded in a Mozilla-based
// browser.
static gchar*
plugin_get_documentbase (NPP instance)
{
PLUGIN_DEBUG ("plugin_get_documentbase\n");
char const* documentbase = NULL;
gchar* documentbase_copy = NULL;
// FIXME: This method is not ideal, but there are no known NPAPI call
// for this. See thread for more information:
// http://www.mail-archive.com/chromium-dev@googlegroups.com/msg04844.html
// Additionally, since it is insecure, we cannot use it for making
// security decisions.
NPObject* window;
browser_functions.getvalue(instance, NPNVWindowNPObject, &window);
NPVariant location;
NPIdentifier location_id = browser_functions.getstringidentifier("location");
browser_functions.getproperty(instance, window, location_id, &location);
NPVariant href;
NPIdentifier href_id = browser_functions.getstringidentifier("href");
browser_functions.getproperty(instance, NPVARIANT_TO_OBJECT(location),
href_id, &href);
std::string href_str = IcedTeaPluginUtilities::NPVariantAsString(href);
documentbase_copy = g_strdup (href_str.c_str());
// Release references.
browser_functions.releasevariantvalue(&href);
browser_functions.releasevariantvalue(&location);
cleanup_done:
PLUGIN_DEBUG ("plugin_get_documentbase return\n");
PLUGIN_DEBUG("plugin_get_documentbase returning: %s\n", documentbase_copy);
return documentbase_copy;
}
// plugin_in_pipe_callback is called when data is available on the
// input pipe, or when the appletviewer crashes or is killed. It may
// be called after data has been destroyed in which case it simply
// returns FALSE to remove itself from the glib main loop.
static gboolean
plugin_in_pipe_callback (GIOChannel* source,
GIOCondition condition,
gpointer plugin_data)
{
PLUGIN_DEBUG ("plugin_in_pipe_callback\n");
gboolean keep_installed = TRUE;
if (condition & G_IO_IN)
{
gchar* message = NULL;
if (g_io_channel_read_line (in_from_appletviewer,
&message, NULL, NULL,
&channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to read line from input channel",
channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to read line from input channel");
} else
{
consume_message(message);
}
g_free (message);
message = NULL;
keep_installed = TRUE;
}
if (condition & (G_IO_ERR | G_IO_HUP))
{
PLUGIN_DEBUG ("appletviewer has stopped.\n");
keep_installed = FALSE;
}
PLUGIN_DEBUG ("plugin_in_pipe_callback return\n");
return keep_installed;
}
static
void consume_plugin_message(gchar* message) {
// internal plugin related message
gchar** parts = g_strsplit (message, " ", 5);
if (g_str_has_prefix(parts[1], "PluginProxyInfo"))
{
gchar* proxy = NULL;
uint32_t len;
gchar* decoded_url = (gchar*) calloc(strlen(parts[4]) + 1, sizeof(gchar));
IcedTeaPluginUtilities::decodeURL(parts[4], &decoded_url);
PLUGIN_DEBUG("parts[0]=%s, parts[1]=%s, reference, parts[3]=%s, parts[4]=%s -- decoded_url=%s\n", parts[0], parts[1], parts[3], parts[4], decoded_url);
gchar* proxy_info;
proxy_info = g_strconcat ("plugin PluginProxyInfo reference ", parts[3], " ", NULL);
if (get_proxy_info(decoded_url, &proxy, &len) == NPERR_NO_ERROR)
{
proxy_info = g_strconcat (proxy_info, proxy, NULL);
}
PLUGIN_DEBUG("Proxy info: %s\n", proxy_info);
plugin_send_message_to_appletviewer(proxy_info);
free(decoded_url);
decoded_url = NULL;
g_free(proxy_info);
proxy_info = NULL;
g_free(proxy);
proxy = NULL;
} else if (g_str_has_prefix(parts[1], "PluginCookieInfo"))
{
gchar* decoded_url = (gchar*) calloc(strlen(parts[4])+1, sizeof(gchar));
IcedTeaPluginUtilities::decodeURL(parts[4], &decoded_url);
gchar* cookie_info = g_strconcat ("plugin PluginCookieInfo reference ", parts[3], " ", NULL);
gchar* cookie_string = NULL;
uint32_t len;
if (get_cookie_info(decoded_url, &cookie_string, &len) == NPERR_NO_ERROR)
{
cookie_info = g_strconcat (cookie_info, cookie_string, NULL);
}
PLUGIN_DEBUG("Cookie info: %s\n", cookie_info);
plugin_send_message_to_appletviewer(cookie_info);
free(decoded_url);
decoded_url = NULL;
g_free(cookie_info);
cookie_info = NULL;
g_free(cookie_string);
cookie_string = NULL;
} else if (g_str_has_prefix(parts[1], "PluginSetCookie"))
{
// Message structure: plugin PluginSetCookie reference -1 <url> <cookie>
gchar** cookie_parts = g_strsplit (message, " ", 6);
if (g_strv_length(cookie_parts) < 6)
{
g_strfreev (parts);
g_strfreev (cookie_parts);
return; // Defensive, message _should_ be properly formatted
}
gchar* decoded_url = (gchar*) calloc(strlen(cookie_parts[4])+1, sizeof(gchar));
IcedTeaPluginUtilities::decodeURL(cookie_parts[4], &decoded_url);
gchar* cookie_string = cookie_parts[5];
uint32_t len = strlen(cookie_string);
if (set_cookie_info(decoded_url, cookie_string, len) == NPERR_NO_ERROR)
{
PLUGIN_DEBUG("Setting cookie for URL %s to %s\n", decoded_url, cookie_string);
} else
{
PLUGIN_DEBUG("Not able to set cookie for URL %s to %s\n", decoded_url, cookie_string);
}
free(decoded_url);
decoded_url = NULL;
g_strfreev (cookie_parts);
cookie_parts = NULL;
}
g_strfreev (parts);
parts = NULL;
}
void consume_message(gchar* message) {
PLUGIN_DEBUG (" PIPE: plugin read: %s\n", message);
if (g_str_has_prefix (message, "instance"))
{
ITNPPluginData* data;
gchar** parts = g_strsplit (message, " ", -1);
guint parts_sz = g_strv_length (parts);
int instance_id = atoi(parts[1]);
NPP instance = (NPP) g_hash_table_lookup(id_to_instance_map,
GINT_TO_POINTER(instance_id));
if (instance_id > 0 && !instance)
{
PLUGIN_DEBUG("Instance %d is not active. Refusing to consume message \"%s\"\n", instance_id, message);
return;
}
else if (instance)
{
data = (ITNPPluginData*) instance->pdata;
}
if (g_str_has_prefix (parts[2], "status"))
{
// clear the "instance X status" parts
strcpy(parts[0], "");
strcpy(parts[1], "");
strcpy(parts[2], "");
// join the rest
gchar* status_message = g_strjoinv(" ", parts);
PLUGIN_DEBUG ("plugin_in_pipe_callback: setting status %s\n", status_message);
(*browser_functions.status) (data->owner, status_message);
g_free(status_message);
status_message = NULL;
}
else if (g_str_has_prefix (parts[1], "internal"))
{
//s->post(message);
}
else
{
// All other messages are posted to the bus, and subscribers are
// expected to take care of them. They better!
java_to_plugin_bus->post(message);
}
g_strfreev (parts);
parts = NULL;
}
else if (g_str_has_prefix (message, "context"))
{
java_to_plugin_bus->post(message);
}
else if (g_str_has_prefix (message, "plugin "))
{
consume_plugin_message(message);
}
else
{
g_print (" Unable to handle message: %s\n", message);
}
}
void get_instance_from_id(int id, NPP& instance)
{
instance = (NPP) g_hash_table_lookup(id_to_instance_map,
GINT_TO_POINTER(id));
}
int get_id_from_instance(NPP instance)
{
int id = GPOINTER_TO_INT(g_hash_table_lookup(instance_to_id_map,
instance));
PLUGIN_DEBUG("Returning id %d for instance %p\n", id, instance);
return id;
}
NPError
get_proxy_info(const char* siteAddr, char** proxy, uint32_t* len)
{
// Only attempt to perform this operation if there is a valid plugin instance
if (g_hash_table_size(instance_to_id_map) <= 0)
{
return NPERR_GENERIC_ERROR;
}
if (browser_functions.getvalueforurl)
{
// As in get_cookie_info, we use the first active instance
gpointer instance=getFirstInTableInstance(instance_to_id_map);
browser_functions.getvalueforurl((NPP) instance, NPNURLVProxy, siteAddr, proxy, len);
} else
{
return NPERR_GENERIC_ERROR;
}
return NPERR_NO_ERROR;
}
// plugin_out_pipe_callback is called when the appletviewer crashes or
// is killed. It may be called after data has been destroyed in which
// case it simply returns FALSE to remove itself from the glib main
// loop.
static gboolean
plugin_out_pipe_callback (GIOChannel* source,
GIOCondition condition,
gpointer plugin_data)
{
PLUGIN_DEBUG ("plugin_out_pipe_callback\n");
ITNPPluginData* data = (ITNPPluginData*) plugin_data;
PLUGIN_DEBUG ("plugin_out_pipe_callback: appletviewer has stopped.\n");
PLUGIN_DEBUG ("plugin_out_pipe_callback return\n");
return FALSE;
}
// remove all components from LD_LIBRARY_PATH, which start with
// MOZILLA_FIVE_HOME; firefox has its own NSS based security provider,
// which conflicts with the one configured in nss.cfg.
static gchar*
plugin_filter_ld_library_path(gchar *path_old)
{
gchar *moz_home = g_strdup (g_getenv ("MOZILLA_FIVE_HOME"));
gchar *moz_prefix;
gchar *path_new;
gchar** components;
int i1, i2;
if (moz_home == NULL || path_old == NULL || strlen (path_old) == 0)
return path_old;
if (g_str_has_suffix (moz_home, "/"))
moz_home[strlen (moz_home - 1)] = '\0';
moz_prefix = g_strconcat (moz_home, "/", NULL);
components = g_strsplit (path_old, ":", -1);
for (i1 = 0, i2 = 0; components[i1] != NULL; i1++)
{
if (g_strcmp0 (components[i1], moz_home) == 0
|| g_str_has_prefix (components[i1], moz_home))
components[i2] = components[i1];
else
components[i2++] = components[i1];
}
components[i2] = NULL;
if (i1 > i2)
path_new = g_strjoinv (":", components);
g_strfreev (components);
g_free (moz_home);
g_free (moz_prefix);
g_free (path_old);
if (path_new == NULL || strlen (path_new) == 0)
{
PLUGIN_DEBUG("Unset LD_LIBRARY_PATH\n");
return NULL;
}
else
{
PLUGIN_DEBUG ("Set LD_LIBRARY_PATH: %s\n", path_new);
return path_new;
}
}
// build the environment to pass to the external plugin process
static gchar**
plugin_filter_environment(void)
{
gchar **var_names = g_listenv();
gchar **new_env = (gchar**) malloc(sizeof(gchar*) * (g_strv_length (var_names) + 1));
int i_var, i_env;
for (i_var = 0, i_env = 0; var_names[i_var] != NULL; i_var++)
{
gchar *env_value = g_strdup (g_getenv (var_names[i_var]));
if (g_str_has_prefix (var_names[i_var], "LD_LIBRARY_PATH"))
env_value = plugin_filter_ld_library_path (env_value);
if (env_value != NULL)
{
new_env[i_env++] = g_strdup_printf ("%s=%s", var_names[i_var], env_value);
g_free (env_value);
}
}
new_env[i_env] = NULL;
return new_env;
}
static NPError
plugin_test_appletviewer ()
{
PLUGIN_DEBUG ("plugin_test_appletviewer: %s\n", get_plugin_executable().c_str());
NPError error = NPERR_NO_ERROR;
gchar* command_line[3] = { NULL, NULL, NULL };
gchar** environment;
command_line[0] = g_strdup (get_plugin_executable().c_str());
command_line[1] = g_strdup("-version");
command_line[2] = NULL;
environment = plugin_filter_environment();
if (!g_spawn_async (NULL, command_line, environment,
(GSpawnFlags) 0,
NULL, NULL, NULL, &channel_error))
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to spawn applet viewer",
channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to spawn applet viewer");
error = NPERR_GENERIC_ERROR;
}
g_strfreev (environment);
g_free (command_line[0]);
command_line[0] = NULL;
g_free (command_line[1]);
command_line[1] = NULL;
g_free (command_line[2]);
command_line[2] = NULL;
PLUGIN_DEBUG ("plugin_test_appletviewer return\n");
return error;
}
static NPError
plugin_start_appletviewer (ITNPPluginData* data)
{
PLUGIN_DEBUG ("plugin_start_appletviewer\n");
NPError error = NPERR_NO_ERROR;
std::vector<std::string> command_line;
gchar** environment = NULL;
std::vector<std::string*>* jvm_args = get_jvm_args();
// Construct command line parameters
command_line.push_back(get_plugin_executable());
//Add JVM args to command_line
for (int i = 0; i < jvm_args->size(); i++)
{
command_line.push_back(*jvm_args->at(i));
}
command_line.push_back(PLUGIN_BOOTCLASSPATH);
// set the classpath to avoid using the default (cwd).
command_line.push_back("-classpath");
command_line.push_back(get_plugin_rt_jar());
// Enable coverage agent if we are running instrumented plugin
#ifdef COVERAGE_AGENT
command_line.push_back(COVERAGE_AGENT);
#endif
if (plugin_debug)
{
command_line.push_back("-Xdebug");
command_line.push_back("-Xnoagent");
//Debug flags
std::string debug_flags = "-Xrunjdwp:transport=dt_socket,address=8787,server=y,";
debug_flags += plugin_debug_suspend ? "suspend=y" : "suspend=n";
command_line.push_back(debug_flags);
}
command_line.push_back("sun.applet.PluginMain");
command_line.push_back(out_pipe_name);
command_line.push_back(in_pipe_name);
// Finished command line parameters
environment = plugin_filter_environment();
std::vector<gchar*> vector_gchar = IcedTeaPluginUtilities::vectorStringToVectorGchar(&command_line);
gchar **command_line_args = &vector_gchar[0];
if (!g_spawn_async (NULL, command_line_args, environment,
(GSpawnFlags) G_SPAWN_DO_NOT_REAP_CHILD,
NULL, NULL, &appletviewer_pid, &channel_error))
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to spawn applet viewer",
channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to spawn applet viewer");
error = NPERR_GENERIC_ERROR;
}
//Free memory
g_strfreev(environment);
IcedTeaPluginUtilities::freeStringPtrVector(jvm_args);
jvm_args = NULL;
command_line_args = NULL;
if (appletviewer_pid)
{
PLUGIN_DEBUG("Initialized VM with pid=%d\n", appletviewer_pid);
appletviewer_watch_id = g_child_watch_add(appletviewer_pid, (GChildWatchFunc) appletviewer_monitor, (gpointer) appletviewer_pid);
}
PLUGIN_DEBUG ("plugin_start_appletviewer return\n");
return error;
}
/*
* Returns JVM options set in itw-settings
*/
std::vector<std::string*>*
get_jvm_args()
{
std::string output;
std::vector<std::string*>* tokenOutput = NULL;
bool args_defined = read_deploy_property_value("deployment.plugin.jvm.arguments", output);
if (!args_defined){
return new std::vector<std::string*>();
}
tokenOutput = IcedTeaPluginUtilities::strSplit(output.c_str(), " \n");
return tokenOutput;
}
/*
* Escape characters for passing to Java.
* "\n" for new line, "\\" for "\", "\:" for ";"
*/
std::string
escape_parameter_string(const char* to_encode) {
std::string encoded;
if (to_encode == NULL)
{
return encoded;
}
size_t length = strlen(to_encode);
for (int i = 0; i < length; i++)
{
if (to_encode[i] == '\n')
encoded += "\\n";
else if (to_encode[i] == '\\')
encoded += "\\\\";
else if (to_encode[i] == ';')
encoded += "\\:";
else
encoded += to_encode[i];
}
return encoded;
}
/*
* Build a string containing an encoded list of parameters to send to the applet viewer.
* The parameters are separated as 'key1;value1;key2;value2;'. As well, they are
* separated and escaped as:
* "\n" for new line, "\\" for "\", "\:" for ";"
*/
std::string
plugin_parameters_string (int argc, char* argn[], char* argv[])
{
PLUGIN_DEBUG ("plugin_parameters_string\n");
std::string parameters;
for (int i = 0; i < argc; i++)
{
if (argv[i] != NULL)
{
std::string name_escaped = escape_parameter_string(argn[i]);
std::string value_escaped = escape_parameter_string(argv[i]);
//Encode parameters and send as 'key1;value1;key2;value2;' etc
parameters += name_escaped;
parameters += ';';
parameters += value_escaped;
parameters += ';';
}
}
PLUGIN_DEBUG ("plugin_parameters_string return\n");
return parameters;
}
// plugin_send_message_to_appletviewer must be called while holding
// data->appletviewer_mutex.
void
plugin_send_message_to_appletviewer (gchar const* message)
{
PLUGIN_DEBUG ("plugin_send_message_to_appletviewer\n");
if (jvm_up)
{
gchar* newline_message = NULL;
gsize bytes_written = 0;
// Send message to appletviewer.
newline_message = g_strdup_printf ("%s\n", message);
// g_io_channel_write_chars will return something other than
// G_IO_STATUS_NORMAL if not all the data is written. In that
// case we fail rather than retrying.
if (g_io_channel_write_chars (out_to_appletviewer,
newline_message, -1, &bytes_written,
&channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to write bytes to output channel",
channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to write bytes to output channel");
}
if (g_io_channel_flush (out_to_appletviewer, &channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to flush bytes to output channel",
channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to flush bytes to output channel");
}
g_free (newline_message);
newline_message = NULL;
PLUGIN_DEBUG (" PIPE: plugin wrote: %s\n", message);
}
PLUGIN_DEBUG ("plugin_send_message_to_appletviewer return\n");
}
/*
* Sends the initialization message (handle/size/url) to the plugin
*/
void
plugin_send_initialization_message(char* instance, gulong handle,
int width, int height, char* url)
{
PLUGIN_DEBUG ("plugin_send_initialization_message\n");
gchar *window_message = g_strdup_printf ("instance %s handle %ld width %d height %d %s",
instance, handle, width, height, url);
plugin_send_message_to_appletviewer (window_message);
g_free (window_message);
window_message = NULL;
PLUGIN_DEBUG ("plugin_send_initialization_message return\n");
}
// Stop the appletviewer process. When this is called the
// appletviewer can be in any of three states: running, crashed or
// hung. If the appletviewer is running then sending it "shutdown"
// will cause it to exit. This will cause
// plugin_out_pipe_callback/plugin_in_pipe_callback to be called and
// the input and output channels to be shut down. If the appletviewer
// has crashed then plugin_out_pipe_callback/plugin_in_pipe_callback
// would already have been called and data->appletviewer_alive cleared
// in which case this function simply returns. If the appletviewer is
// hung then this function will be successful and the input and output
// watches will be removed by plugin_data_destroy.
// plugin_stop_appletviewer must be called with
// data->appletviewer_mutex held.
static void
plugin_stop_appletviewer ()
{
PLUGIN_DEBUG ("plugin_stop_appletviewer\n");
if (jvm_up)
{
// Shut down the appletviewer.
gsize bytes_written = 0;
if (out_to_appletviewer)
{
if (g_io_channel_write_chars (out_to_appletviewer, "shutdown",
-1, &bytes_written, &channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to write shutdown message to"
" appletviewer", channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to write shutdown message to");
}
if (g_io_channel_flush (out_to_appletviewer, &channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to write shutdown message to"
" appletviewer", channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to write shutdown message to");
}
if (g_io_channel_shutdown (out_to_appletviewer,
TRUE, &channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to shut down appletviewer"
" output channel", channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to shut down appletviewer");
}
}
if (in_from_appletviewer)
{
if (g_io_channel_shutdown (in_from_appletviewer,
TRUE, &channel_error)
!= G_IO_STATUS_NORMAL)
{
if (channel_error)
{
PLUGIN_ERROR_TWO ("Failed to shut down appletviewer"
" input channel", channel_error->message);
g_error_free (channel_error);
channel_error = NULL;
}
else
PLUGIN_ERROR ("Failed to shut down appletviewer");
}
}
}
jvm_up = FALSE;
sleep(2); /* Needed to prevent crashes during debug (when JDWP port is not freed by the kernel right away) */
PLUGIN_DEBUG ("plugin_stop_appletviewer return\n");
}
static void appletviewer_monitor(GPid pid, gint status, gpointer data)
{
PLUGIN_DEBUG ("appletviewer_monitor\n");
jvm_up = FALSE;
pid = -1;
PLUGIN_DEBUG ("appletviewer_monitor return\n");
}
static void
plugin_data_destroy (NPP instance)
{
PLUGIN_DEBUG ("plugin_data_destroy\n");
ITNPPluginData* tofree = (ITNPPluginData*) instance->pdata;
// Remove instance from map
gpointer id_ptr = g_hash_table_lookup(instance_to_id_map, instance);
if (id_ptr)
{
gint id = GPOINTER_TO_INT(id_ptr);
g_hash_table_remove(instance_to_id_map, instance);
g_hash_table_remove(id_to_instance_map, id_ptr);
}
tofree->window_handle = NULL;
tofree->window_height = 0;
tofree->window_width = 0;
// cleanup_appletviewer_mutex:
g_mutex_free (tofree->appletviewer_mutex);
tofree->appletviewer_mutex = NULL;
// cleanup_instance_string:
g_free (tofree->instance_id);
tofree->instance_id = NULL;
// cleanup applet tag
g_free (tofree->parameters_string);
tofree->parameters_string = NULL;
g_free(tofree->source);
tofree->source = NULL;
// cleanup_data:
// Eliminate back-pointer to plugin instance.
tofree->owner = NULL;
(*browser_functions.memfree) (tofree);
tofree = NULL;
PLUGIN_DEBUG ("plugin_data_destroy return\n");
}
static bool
initialize_browser_functions(const NPNetscapeFuncs* browserTable)
{
#define NPNETSCAPEFUNCS_LAST_FIELD_USED (browserTable->setvalueforurl)
//Determine the size in bytes, as a difference of the address past the last used field
//And the browser table address
size_t usedSize = (char*)(1 + &NPNETSCAPEFUNCS_LAST_FIELD_USED) - (char*)browserTable;
// compare the reported size versus the size we required
if (browserTable->size < usedSize)
{
return false;
}
//Ensure any unused fields are NULL
memset(&browser_functions, 0, sizeof(NPNetscapeFuncs));
//browserTable->size can be larger than sizeof(NPNetscapeFuncs) (PR1106)
size_t copySize = browserTable->size < sizeof(NPNetscapeFuncs) ?
browserTable->size : sizeof(NPNetscapeFuncs);
//Copy fields according to given size
memcpy(&browser_functions, browserTable, copySize);
return true;
}
/* Set the plugin table to the correct contents, taking care not to write past
* the provided object space */
static bool
initialize_plugin_table(NPPluginFuncs* pluginTable)
{
#define NPPLUGINFUNCS_LAST_FIELD_USED (pluginTable->getvalue)
//Determine the size in bytes, as a difference of the address past the last used field
//And the browser table address
size_t usedSize = (char*)(1 + &NPPLUGINFUNCS_LAST_FIELD_USED) - (char*)pluginTable;
// compare the reported size versus the size we required
if (pluginTable->size < usedSize)
return false;
pluginTable->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;
pluginTable->size = sizeof (NPPluginFuncs);
pluginTable->newp = NPP_NewProcPtr (ITNP_New);
pluginTable->destroy = NPP_DestroyProcPtr (ITNP_Destroy);
pluginTable->setwindow = NPP_SetWindowProcPtr (ITNP_SetWindow);
pluginTable->newstream = NPP_NewStreamProcPtr (ITNP_NewStream);
pluginTable->destroystream = NPP_DestroyStreamProcPtr (ITNP_DestroyStream);
pluginTable->asfile = NPP_StreamAsFileProcPtr (ITNP_StreamAsFile);
pluginTable->writeready = NPP_WriteReadyProcPtr (ITNP_WriteReady);
pluginTable->write = NPP_WriteProcPtr (ITNP_Write);
pluginTable->print = NPP_PrintProcPtr (ITNP_Print);
pluginTable->urlnotify = NPP_URLNotifyProcPtr (ITNP_URLNotify);
pluginTable->getvalue = NPP_GetValueProcPtr (ITNP_GetValue);