This patch adds the browser plugin to the main Gtk-VNC sources.The browser plugin lives in the plugin/ directory. It is disabled always by default. To enable it, the user must:
./configure --enable-plugin (and of course it also checks for the required libraries). There is a detailed plugin/README file.It compiles without warnings, on Fedora 8 at least (ie. passes ./configure --enable-plugin --enable-warnings --enable-fatal-warnings; make).
Rich. -- Emerging Technologies, Red Hat - http://et.redhat.com/~rjones/ Registered Address: Red Hat UK Ltd, Amberley Place, 107-111 Peascod Street, Windsor, Berkshire, SL4 1TE, United Kingdom. Registered in England and Wales under Company Registration No. 03798903
# HG changeset patch # User "Richard W.M. Jones <rjones redhat com>" # Date 1200044633 0 # Node ID c49bf3e93ba17f24ca7d6255b11d94b056582afa # Parent 4964aaeb8cccc45942e618f27f4e5468c31ec436 Ignore generated files. diff -r 4964aaeb8ccc -r c49bf3e93ba1 .hgignore --- a/.hgignore Thu Jan 10 22:17:45 2008 -0600 +++ b/.hgignore Fri Jan 11 09:43:53 2008 +0000 @@ -29,6 +29,8 @@ Makefile\.in$ ^INSTALL$ ^depcomp$ ^install-sh$ +^compile$ +^src/vncmarshal\.[ch]$ syntax: glob examples/*.o # HG changeset patch # User "Richard W.M. Jones <rjones redhat com>" # Date 1200052674 0 # Node ID b3a614359afbf7c801f86e9529d7e7bce631a3b5 # Parent c49bf3e93ba17f24ca7d6255b11d94b056582afa Gtk-VNC browser plugin. diff -r c49bf3e93ba1 -r b3a614359afb .hgignore --- a/.hgignore Fri Jan 11 09:43:53 2008 +0000 +++ b/.hgignore Fri Jan 11 11:57:54 2008 +0000 @@ -31,6 +31,11 @@ Makefile\.in$ ^install-sh$ ^compile$ ^src/vncmarshal\.[ch]$ +^plugin/\.deps/ +^plugin/\.libs/ +^plugin/libgtk_vnc_plugin.la$ +^plugin/libgtk_vnc_plugin_la-.* +^plugin/gtk-vnc-plugin.so syntax: glob examples/*.o diff -r c49bf3e93ba1 -r b3a614359afb Makefile.am --- a/Makefile.am Fri Jan 11 09:43:53 2008 +0000 +++ b/Makefile.am Fri Jan 11 11:57:54 2008 +0000 @@ -1,5 +1,5 @@ -SUBDIRS = src examples +SUBDIRS = src examples plugin pkgconfig_DATA = @PACKAGE -1 0 pc pkgconfigdir = $(libdir)/pkgconfig diff -r c49bf3e93ba1 -r b3a614359afb configure.ac --- a/configure.ac Fri Jan 11 09:43:53 2008 +0000 +++ b/configure.ac Fri Jan 11 11:57:54 2008 +0000 @@ -159,14 +159,33 @@ fi fi AC_SUBST(DEBUG_CFLAGS) +dnl --enable-plugin to enable the browser plugin. +NSPR_REQUIRED=4.0.0 +FIREFOX_PLUGIN_REQUIRED=2.0.0 +AC_ARG_ENABLE(plugin, + [ --enable-plugin=[no/yes] enable browser plugin [default=no]],, + enable_plugin=no) +if test "x$enable_plugin" = "xyes"; then + dnl Check for Netscape Portable Runtime development package. + PKG_CHECK_MODULES(NSPR, nspr >= $NSPR_REQUIRED) + dnl Check for Firefox plugin package (also includes NSPR cflags/libs). + PKG_CHECK_MODULES(FIREFOX_PLUGIN, + firefox-plugin >= $FIREFOX_PLUGIN_REQUIRED) + AC_SUBST(FIREFOX_PLUGIN_CFLAGS) + AC_SUBST(FIREFOX_PLUGIN_LIBS) +fi + AM_CONDITIONAL(WITH_PYTHON, [test "$WITH_PYTHON" = "yes"]) AM_CONDITIONAL(WITH_EXAMPLES, [test "$WITH_EXAMPLES" = "yes"]) + +AM_CONDITIONAL(ENABLE_PLUGIN, [test "$enable_plugin" = "yes"]) AC_CONFIG_FILES( Makefile src/Makefile examples/Makefile + plugin/Makefile gtk-vnc-1.0.pc gtk-vnc.spec ) diff -r c49bf3e93ba1 -r b3a614359afb plugin/Makefile.am --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugin/Makefile.am Fri Jan 11 11:57:54 2008 +0000 @@ -0,0 +1,34 @@ +if ENABLE_PLUGIN + +# What we really want is 'noinst_LTLIBRARIES', so that it builds the +# shared library but lets us control how we install it. However +# if you do that, automake thinks you're trying to build a "libtool +# convenience library" and no longer builds a shared library at all. +# Very unhelpful. So instead build and install the library in libdir +# but delete it in the install hook below and install it where we want. +# I hate automake and libtool. +lib_LTLIBRARIES = libgtk-vnc-plugin.la + +libgtk_vnc_plugin_la_SOURCES = \ + gtk-vnc-plugin.c gtk-vnc-plugin.h npshell.c npunix.c +libgtk_vnc_plugin_la_LIBADD = \ + ../src/libgtk-vnc-1.0.la @GTK_LIBS@ @FIREFOX_PLUGIN_LIBS@ +libgtk_vnc_plugin_la_CFLAGS = \ + -I$(top_srcdir)/src @GTK_CFLAGS@ @FIREFOX_PLUGIN_CFLAGS@ \ + @WARNING_CFLAGS@ @WERROR_CFLAGS@ + +all-local: gtk-vnc-plugin.so + +gtk-vnc-plugin.so: libgtk-vnc-plugin.la + cp .libs/libgtk-vnc-plugin.so.0.0.0 $@ + +install-exec-hook: + rm -f $(libdir)/libgtk-vnc-plugin.* + $(install_sh) -d $(libdir)/mozilla/plugins + $(install_sh) -c -m 0755 gtk-vnc-plugin.so $(libdir)/mozilla/plugins + +EXTRA_DIST = README + +CLEANFILES = gtk-vnc-plugin.so + +endif \ No newline at end of file diff -r c49bf3e93ba1 -r b3a614359afb plugin/README --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugin/README Fri Jan 11 11:57:54 2008 +0000 @@ -0,0 +1,120 @@ + README for plugin + ========================== + by Richard W.M. Jones <rjones redhat com> + +This is a web browser plugin featuring a Gtk VNC widget which can be +embedded in a web page. + +This code is primarily an example of how to write such a plugin. You +could use it directly, but it's more likely that you'll want to +customise it for particular situations. + +The plugin supports all browsers which supply the NPAPI and XEmbed +APIs. This includes all modern Mozilla/Firefox-derived browsers on +Unix, and [untested] WebKit-based browsers (eg. Konqueror, Safari) and +Opera. + +All the code is based on Adobe's demonstration XEmbed-based browser +called DiamondX (http://multimedia.cx/diamondx/). + +Building +-------- + +The code is not enabled by default. To enable, at the top-level +directory do: + + ./configure --enable-plugin + +You will need the following APIs/header files for this to work: + + npapi.h (from a Firefox or Mozilla development package) + npupp.h + + gtk/gtk.h + + X11/Xlib.h (X11 development package) + + NSPR (Netscape Portable Runtime development package) + +Other plugins usually come with their own npapi.h and npupp.h, copied +from the Mozilla source code. However since in Fedora we ship a +'firefox-devel' package which contains these headers (albeit in a +rather inconvenient location), I have not duplicated them here. + +If configuration was successful then the usual 'make' at the toplevel +will build the plugin (gtk-vnc-plugin.so). + +Installing +---------- + +The 'make install' rule installs the plugin (gtk-vnc-plugin.so) in the +site-wide Mozilla plugins directory ($libdir/mozilla/plugins). + +For a single user install you can also do this: + + cp gtk-vnc-plugin.so $HOME/.mozilla/plugins + +For other browsers, you'll need to find out where they keep their +plugins. + +Testing +------- + +Restart your browser. In the location bar, type: + + about:plugins + +Amongst your other plugins you should see the GTK-VNC plugin: + + GTK-VNC plugin + + File name: gtk-vnc-plugin.so + VNC (remote desktop) viewer plugin + + MIME Type Description Suffixes Enabled + application/x-gtk-vnc VNC viewer gtk-vnc Yes + +If that appears, then next edit the test.html page in the current +directory. You will need to change the source of this page to point +to a working VNC server (eg. a machine on your local network). + +Then load the edited 'test.html' page into your browser, and you +should see a VNC widget and the desktop of the remote server. + +Embedding +--------- + +The basic embedding HTML code is: + + <embed type="application/x-gtk-vnc" + width="800" + height="600" + host="192.168.2.129" port="5900"> + </embed> + +Both host and port are required, otherwise the plugin (currently) +won't do anything. + +Future work +----------- + +* Try to get it working in other browsers. +* Compile on Windows. +* Get desktop-resize working properly. +* Allow remote control from Javascript. +* Allow authentication methods to be specified as parameters. + +Security +-------- + +Obviously if you have this plugin, then any web page could invoke it, +which would entail a VNC connection to any IP address/port +combination, including addresses which are behind firewalls. As it +stands, this doesn't seem like very much risk because (1) Gtk-VNC will +only talk to VNC servers which respond with the appropriate VNC +greeting, and (2) in any case the web page can't query the plugin to +see if the connection was successful. + +Security will become an issue if the plugin is extended to allow +control / status from Javascript. You might want to think about +having a whitelist of sites which are allowed to use the plugin. diff -r c49bf3e93ba1 -r b3a614359afb plugin/gtk-vnc-plugin.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugin/gtk-vnc-plugin.c Fri Jan 11 11:57:54 2008 +0000 @@ -0,0 +1,317 @@ +/* + GTK-VNC-PLUGIN + + By Richard W.M. Jones <rjones redhat com> + Copyright (C) 2008 Red Hat Inc. + + Largely based on DiamondX (http://multimedia.cx/diamondx/), which itself + is based on Mozilla sources. + + DiamondX copyright notice: + + Example XEmbed-aware Mozilla browser plugin by Adobe. + + Copyright (c) 2007 Adobe Systems Incorporated + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#include <stdio.h> +#include <stdlib.h> +#include <vncdisplay.h> + +#include "gtk-vnc-plugin.h" + +static void +debug (const char *msg, ...) +{ + va_list args; + + va_start (args, msg); + vfprintf (stderr, msg, args); + va_end (args); + fprintf (stderr, "\n"); + fflush (stderr); +} + +static void +vnc_connected (GtkWidget *vnc G_GNUC_UNUSED, void *Thisv) +{ + PluginInstance *This = (PluginInstance *) Thisv; + + debug ("vnc_connected, This=%p", This); +} + +static void +vnc_disconnected (GtkWidget *vnc G_GNUC_UNUSED, void *Thisv) +{ + PluginInstance *This = (PluginInstance *) Thisv; + + debug ("vnc_disconnected, This=%p", This); +} + +static void +vnc_auth_credential (GtkWidget *vnc, GValueArray *creds, void *Thisv) +{ + GtkWidget *dlg = NULL; + PluginInstance *This = (PluginInstance *) Thisv; + unsigned i, prompt = 0; + const char **data; + + debug ("vnc_auth_credential, This=%p", This); + + data = g_new0 (const char *, creds->n_values); + + for (i = 0; i < creds->n_values; ++i) { + GValue *cred = g_value_array_get_nth (creds, i); + switch (g_value_get_enum (cred)) { + case VNC_DISPLAY_CREDENTIAL_USERNAME: + case VNC_DISPLAY_CREDENTIAL_PASSWORD: + prompt++; + break; + case VNC_DISPLAY_CREDENTIAL_CLIENTNAME: + data[i] = "gvncviewer"; + break; + } + } + + /* Prompt user for username and password. */ + if (prompt) { + GtkWidget **label, **entry, *box, *vbox; + int row, response; + + dlg = gtk_dialog_new_with_buttons + ("Gtk-VNC: Authentication required", + GTK_WINDOW (This->container), + GTK_DIALOG_MODAL|GTK_DIALOG_DESTROY_WITH_PARENT, + GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, + GTK_STOCK_OK, GTK_RESPONSE_OK, + NULL); + gtk_dialog_set_default_response (GTK_DIALOG(dlg), GTK_RESPONSE_OK); + + box = gtk_table_new (creds->n_values, 2, FALSE); + label = g_new (GtkWidget *, prompt); + entry = g_new (GtkWidget *, prompt); + + for (i = 0, row = 0; i < creds->n_values; ++i) { + GValue *cred = g_value_array_get_nth (creds, i); + switch (g_value_get_enum(cred)) { + case VNC_DISPLAY_CREDENTIAL_USERNAME: + label[row] = gtk_label_new("Username:"); + break; + case VNC_DISPLAY_CREDENTIAL_PASSWORD: + label[row] = gtk_label_new("Password:"); + break; + default: + continue; + } + entry[row] = gtk_entry_new(); + + gtk_table_attach(GTK_TABLE(box), label[i], 0, 1, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3); + gtk_table_attach(GTK_TABLE(box), entry[i], 1, 2, row, row+1, GTK_SHRINK, GTK_SHRINK, 3, 3); + row++; + } + + vbox = gtk_bin_get_child(GTK_BIN(dlg)); + gtk_container_add(GTK_CONTAINER(vbox), box); + + gtk_widget_show_all(dlg); + response = gtk_dialog_run(GTK_DIALOG(dlg)); + gtk_widget_hide(GTK_WIDGET(dlg)); + + if (response == GTK_RESPONSE_OK) { + for (i = 0, row = 0 ; i < creds->n_values ; i++) { + GValue *cred = g_value_array_get_nth(creds, i); + switch (g_value_get_enum(cred)) { + case VNC_DISPLAY_CREDENTIAL_USERNAME: + case VNC_DISPLAY_CREDENTIAL_PASSWORD: + data[i] = gtk_entry_get_text(GTK_ENTRY(entry[row])); + row++; + break; + } + } + } + } + + /* Set the credentials. */ + for (i = 0 ; i < creds->n_values ; i++) { + GValue *cred = g_value_array_get_nth(creds, i); + if (data[i]) { + if (vnc_display_set_credential(VNC_DISPLAY(vnc), + g_value_get_enum(cred), + data[i])) { + debug ("Failed to set credential type %d", g_value_get_enum(cred)); + vnc_display_close(VNC_DISPLAY(vnc)); + } + } else { + debug ("Unsupported credential type %d", g_value_get_enum(cred)); + vnc_display_close(VNC_DISPLAY(vnc)); + } + } + + g_free (data); + if (dlg) + gtk_widget_destroy (GTK_WIDGET(dlg)); +} + +NPError +GtkVNCXSetWindow (NPP instance, NPWindow *window) +{ + PluginInstance *This; + NPSetWindowCallbackStruct *ws_info; + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + This = (PluginInstance*) instance->pdata; + + debug ("GtkVNCXSetWindow, This=%p", This); + + if (This == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + ws_info = (NPSetWindowCallbackStruct *)window->ws_info; + + /* Mozilla likes to re-run its greatest hits */ + if (window == This->window && + window->x == This->x && + window->y == This->y && + window->width == This->width && + window->height == This->height) { + debug ("gtk-vnc-plugin: window re-run; returning"); + return NPERR_NO_ERROR; + } + + This->window = window; + This->x = window->x; + This->y = window->y; + This->width = window->width; + This->height = window->height; + + /* Create a GtkPlug container and a Gtk-VNC widget inside it. */ + This->container = gtk_plug_new ((GdkNativeWindow)(long)window->window); + This->vnc = vnc_display_new (); + + /* Make sure the canvas is capable of receiving focus. */ + GTK_WIDGET_SET_FLAGS (GTK_WIDGET(This->vnc), GTK_CAN_FOCUS); + + /* All the events that our canvas wants to receive */ + gtk_widget_add_events + (This->vnc, + GDK_BUTTON_PRESS_MASK | + GDK_BUTTON_RELEASE_MASK | + GDK_KEY_PRESS_MASK | + GDK_KEY_RELEASE_MASK | + GDK_POINTER_MOTION_MASK | + GDK_SCROLL_MASK | + GDK_EXPOSURE_MASK | + GDK_VISIBILITY_NOTIFY_MASK | + GDK_ENTER_NOTIFY_MASK | + GDK_LEAVE_NOTIFY_MASK | + GDK_FOCUS_CHANGE_MASK); + + /* Connect up the signals. */ + g_signal_connect (G_OBJECT(This->vnc), "vnc-connected", + G_CALLBACK(vnc_connected), This); + g_signal_connect (G_OBJECT(This->vnc), "vnc-disconnected", + G_CALLBACK(vnc_disconnected), This); +#if 0 + g_signal_connect (G_OBJECT(This->vnc), "vnc-initialized", + G_CALLBACK(vnc_initialized), This); +#endif + g_signal_connect (G_OBJECT(This->vnc), "vnc-auth-credential", + G_CALLBACK(vnc_auth_credential), This); +#if 0 + g_signal_connect (G_OBJECT(This->vnc), "vnc-auth-failure", + G_CALLBACK(vnc_auth_failure), This); + g_signal_connect (G_OBJECT(This->vnc), "vnc-desktop-resize", + G_CALLBACK(vnc_desktop_resize), This); + g_signal_connect (G_OBJECT(This->vnc), "vnc-pointer-grab", + G_CALLBACK(vnc_pointer_grab), This); + g_signal_connect (G_OBJECT(This->vnc), "vnc-pointer-ungrab", + G_CALLBACK(vnc_pointer_ungrab), This); + g_signal_connect (G_OBJECT(This->vnc), "key-press-event", + G_CALLBACK(vnc_screenshow), This); +#endif + + gtk_widget_show (This->vnc); + + gtk_container_add (GTK_CONTAINER(This->container), This->vnc); + + gtk_widget_show (This->container); + + /*gtk_widget_realize (This->vnc);*/ + + /* Start connection to remote host. */ + if (This->host && This->port) { + debug ("starting connection to %s:%s", This->host, This->port); + vnc_display_open_host (VNC_DISPLAY(This->vnc), This->host, This->port); + } + + return NPERR_NO_ERROR; +} + +NPError +GtkVNCDestroyWindow (NPP instance) +{ + PluginInstance *This = (PluginInstance*) instance->pdata; + + debug ("GtkVNCDestroyWindow, This=%p", This); + + if (This && This->container) { + gtk_widget_destroy (This->container); + This->container = This->vnc = NULL; + } + + return NPERR_NO_ERROR; +} + +static NPWindow windowlessWindow; + +int16 +GtkVNCXHandleEvent(NPP instance, void *event) +{ + XGraphicsExposeEvent exposeEvent; + XEvent *nsEvent; + + debug ("GtkVNCXHandleEvent"); + + nsEvent = (XEvent *) event; + exposeEvent = nsEvent->xgraphicsexpose; + + /*printf(" event: x, y, w, h = %d, %d, %d, %d; display @ %p, window/drawable = %d\n", + exposeEvent.x, + exposeEvent.y, + exposeEvent.width, + exposeEvent.height, + exposeEvent.display, + exposeEvent.drawable);*/ + + windowlessWindow.window = exposeEvent.display; + windowlessWindow.x = exposeEvent.x; + windowlessWindow.y = exposeEvent.y; + windowlessWindow.width = exposeEvent.width; + windowlessWindow.height = exposeEvent.height; + windowlessWindow.ws_info = (void *)exposeEvent.drawable; + + NPP_SetWindow(instance, &windowlessWindow); + + return 0; +} diff -r c49bf3e93ba1 -r b3a614359afb plugin/gtk-vnc-plugin.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugin/gtk-vnc-plugin.h Fri Jan 11 11:57:54 2008 +0000 @@ -0,0 +1,66 @@ +/* + GTK-VNC-PLUGIN + + By Richard W.M. Jones <rjones redhat com> + Copyright (C) 2008 Red Hat Inc. + + Largely based on DiamondX (http://multimedia.cx/diamondx/), which itself + is based on Mozilla sources. + + DiamondX copyright notice: + + Example XEmbed-aware Mozilla browser plugin by Adobe. + + Copyright (c) 2007 Adobe Systems Incorporated + + Permission is hereby granted, free of charge, to any person obtaining + a copy of this software and associated documentation files (the + "Software"), to deal in the Software without restriction, including + without limitation the rights to use, copy, modify, merge, publish, + distribute, sublicense, and/or sell copies of the Software, and to + permit persons to whom the Software is furnished to do so, subject to + the following conditions: + + The above copyright notice and this permission notice shall be + included in all copies or substantial portions of the Software. + + THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, + EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF + MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND + NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE + LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION + OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION + WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. +*/ + +#ifndef GTK_VNC_PLUGIN_H +#define GTK_VNC_PLUGIN_H + +#include <npapi.h> +#include <gtk/gtk.h> +#include <X11/Xlib.h> + +#define PLUGIN_NAME "GTK-VNC plugin" +#define MIME_TYPES_HANDLED "application/x-gtk-vnc:gtk-vnc:VNC viewer" +#define PLUGIN_DESCRIPTION "VNC (remote desktop) viewer plugin" + +typedef struct { + uint16 mode; + NPWindow *window; + int32 x, y; + uint32 width, height; + + NPP instance; + NPBool pluginsHidden; + + GtkWidget *container; + GtkWidget *vnc; + + char *host, *port; +} PluginInstance; + +extern NPError GtkVNCXSetWindow (NPP instance, NPWindow* window); +extern NPError GtkVNCDestroyWindow (NPP instance); +extern int16 GtkVNCXHandleEvent (NPP instance, void* event); + +#endif /* GTK_VNC_PLUGIN_H */ diff -r c49bf3e93ba1 -r b3a614359afb plugin/npshell.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugin/npshell.c Fri Jan 11 11:57:54 2008 +0000 @@ -0,0 +1,396 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Stephen Mak <smak sun com> + * + * Alternatively, the contents of this file may be used under the terms of + * either the GNU General Public License Version 2 or later (the "GPL"), or + * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/* + * npshell.c + * + * Netscape Client Plugin API + * - Function that need to be implemented by plugin developers + * + * This file defines a "shell" plugin that plugin developers can use + * as the basis for a real plugin. This shell just provides empty + * implementations of all functions that the plugin can implement + * that will be called by Netscape (the NPP_xxx methods defined in + * npapi.h). + * + * dp Suresh <dp netscape com> + * updated 5/1998 <pollmann netscape com> + * updated 9/2000 <smak sun com> + * + */ + + +/* +The contents of this file are subject to the Mozilla Public License + +Version 1.1 (the "License"); you may not use this file except in compliance +with the License. You may obtain a copy of the License at http://www.mozilla.org/MPL/ + +Software distributed under the License is distributed on an "AS IS" basis, +WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License for +the specific language governing rights and limitations under the License. + +The Original Code is stub code that defines the binary interface to a Mozilla +plugin. + +The Initial Developer of the Original Code is Mozilla. + +Portions created by Adobe Systems Incorporated are Copyright (C) 2007. All Rights Reserved. + +Contributor(s): Adobe Systems Incorporated. +*/ + + +#include <stdio.h> +#include <string.h> + +#include <npapi.h> +#include <npupp.h> + +#include "gtk-vnc-plugin.h" + +static void +debug (const char *msg, ...) +{ + va_list args; + + va_start (args, msg); + vfprintf (stderr, msg, args); + va_end (args); + fprintf (stderr, "\n"); + fflush (stderr); +} + +/*********************************************************************** + * + * Implementations of plugin API functions + * + ***********************************************************************/ + +char * +NPP_GetMIMEDescription(void) +{ + return (char *) MIME_TYPES_HANDLED; +} + +NPError +NPP_GetValue(NPP instance G_GNUC_UNUSED, NPPVariable variable, void *value) +{ + NPError err = NPERR_NO_ERROR; + + debug ("NPP_GetValue %d", variable); + + switch (variable) { + case NPPVpluginNameString: + *((const char **)value) = PLUGIN_NAME; + break; + case NPPVpluginDescriptionString: + *((const char **)value) = PLUGIN_DESCRIPTION; + break; + case NPPVpluginNeedsXEmbed: + *((PRBool *)value) = PR_TRUE; + break; + default: + err = NPERR_GENERIC_ERROR; + } + return err; +} + +NPError +NPP_Initialize(void) +{ + debug ("NPP_Initialize"); + + gtk_init(0, 0); + + return NPERR_NO_ERROR; +} + +#ifdef OJI +jref +NPP_GetJavaClass() +{ + return NULL; +} +#endif + +void +NPP_Shutdown(void) +{ + debug ("NPP_Shutdown"); +} + +NPError +NPP_New(NPMIMEType pluginType G_GNUC_UNUSED, + NPP instance, + uint16 mode, + int16 argc, + char* argn[], + char* argv[], + NPSavedData *saved G_GNUC_UNUSED) +{ + PluginInstance *This; + NPError err = NPERR_NO_ERROR; + PRBool supportsXEmbed = PR_FALSE; + NPNToolkitType toolkit = 0; + int i; + char *key, *value; + + debug ("NPP_New"); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + /* http://developer.mozilla.org/en/docs/XEmbed_Extension_for_Mozilla_Plugins + * Check for XEmbed and Gtk toolkit. + */ + err = NPN_GetValue (instance, + NPNVSupportsXEmbedBool, + (void *)&supportsXEmbed); + if (err != NPERR_NO_ERROR || supportsXEmbed != PR_TRUE) + return NPERR_INCOMPATIBLE_VERSION_ERROR; + + err = NPN_GetValue (instance, + NPNVToolkit, + (void *)&toolkit); + if (err != NPERR_NO_ERROR || toolkit != NPNVGtk2) + return NPERR_INCOMPATIBLE_VERSION_ERROR; + + instance->pdata = NPN_MemAlloc(sizeof(PluginInstance)); + + This = (PluginInstance*) instance->pdata; + + if (This == NULL) { + return NPERR_OUT_OF_MEMORY_ERROR; + } + + memset(This, 0, sizeof(PluginInstance)); + + /* Mode is NP_EMBED, NP_FULL, or NP_BACKGROUND (see npapi.h). */ + This->mode = mode; + This->instance = instance; + This->host = This->port = NULL; + + /* Read the parameters passed to the plugin. */ + for (i = 0; i < argc; i++) + { + key = argn[i]; + value = argv[i]; + + if (strcmp (argn[i], "host") == 0) + This->host = strdup (argv[i]); + else if (strcmp (argn[i], "port") == 0) + This->port = strdup (argv[i]); + } + + return NPERR_NO_ERROR; +} + +NPError +NPP_Destroy(NPP instance, NPSavedData** save G_GNUC_UNUSED) +{ + PluginInstance* This; + + debug ("NPP_Destroy"); + + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + This = (PluginInstance*) instance->pdata; + + if (This != NULL) + { + (void) GtkVNCDestroyWindow (instance); + if (This->host) free (This->host); + if (This->port) free (This->port); + NPN_MemFree(instance->pdata); + instance->pdata = NULL; + } + + return NPERR_NO_ERROR; +} + + +NPError +NPP_SetWindow(NPP instance, NPWindow* window) +{ + debug ("NPP_SetWindow"); + + return GtkVNCXSetWindow(instance, window); +} + +int32 +NPP_WriteReady(NPP instance, NPStream *stream) +{ + /*printf("NPP_WriteReady()\n");*/ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + /* We don't want any data, kill the stream */ + NPN_DestroyStream(instance, stream, NPRES_DONE); + + /* Number of bytes ready to accept in NPP_Write() */ + return -1L; /* don't accept any bytes in NPP_Write() */ +} + +int32 +NPP_Write(NPP instance, NPStream *stream, + int32 offset G_GNUC_UNUSED, int32 len G_GNUC_UNUSED, + void *buffer G_GNUC_UNUSED) +{ + /*printf("NPP_Write()\n");*/ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + /* We don't want any data, kill the stream */ + NPN_DestroyStream(instance, stream, NPRES_DONE); + + return -1L; /* don't accept any bytes in NPP_Write() */ +} + +NPError +NPP_DestroyStream(NPP instance, NPStream *stream G_GNUC_UNUSED, + NPError reason G_GNUC_UNUSED) +{ + /*printf("NPP_DestroyStream()\n");*/ + if (instance == NULL) + return NPERR_INVALID_INSTANCE_ERROR; + + /***** Insert NPP_DestroyStream code here *****\ + PluginInstance* This; + This = (PluginInstance*) instance->pdata; + \**********************************************/ + + return NPERR_NO_ERROR; +} + +void +NPP_StreamAsFile(NPP instance G_GNUC_UNUSED, NPStream *stream G_GNUC_UNUSED, + const char* fname G_GNUC_UNUSED) +{ + /*printf("NPP_StreamAsFile()\n");*/ + /***** Insert NPP_StreamAsFile code here *****\ + PluginInstance* This; + if (instance != NULL) + This = (PluginInstance*) instance->pdata; + \*********************************************/ +} + +void +NPP_URLNotify(NPP instance G_GNUC_UNUSED, const char* url G_GNUC_UNUSED, + NPReason reason G_GNUC_UNUSED, void* notifyData G_GNUC_UNUSED) +{ + /*printf("NPP_URLNotify()\n");*/ + /***** Insert NPP_URLNotify code here *****\ + PluginInstance* This; + if (instance != NULL) + This = (PluginInstance*) instance->pdata; + \*********************************************/ +} + + +void +NPP_Print(NPP instance, NPPrint* printInfo) +{ + /*printf("NPP_Print()\n");*/ + if(printInfo == NULL) + return; + + if (instance != NULL) { + /***** Insert NPP_Print code here *****\ + PluginInstance* This = (PluginInstance*) instance->pdata; + \**************************************/ + + if (printInfo->mode == NP_FULL) { + /* + * PLUGIN DEVELOPERS: + * If your plugin would like to take over + * printing completely when it is in full-screen mode, + * set printInfo->pluginPrinted to TRUE and print your + * plugin as you see fit. If your plugin wants Netscape + * to handle printing in this case, set + * printInfo->pluginPrinted to FALSE (the default) and + * do nothing. If you do want to handle printing + * yourself, printOne is true if the print button + * (as opposed to the print menu) was clicked. + * On the Macintosh, platformPrint is a THPrint; on + * Windows, platformPrint is a structure + * (defined in npapi.h) containing the printer name, port, + * etc. + */ + + /***** Insert NPP_Print code here *****\ + void* platformPrint = + printInfo->print.fullPrint.platformPrint; + NPBool printOne = + printInfo->print.fullPrint.printOne; + \**************************************/ + + /* Do the default*/ + printInfo->print.fullPrint.pluginPrinted = FALSE; + } + else { /* If not fullscreen, we must be embedded */ + /* + * PLUGIN DEVELOPERS: + * If your plugin is embedded, or is full-screen + * but you returned false in pluginPrinted above, NPP_Print + * will be called with mode == NP_EMBED. The NPWindow + * in the printInfo gives the location and dimensions of + * the embedded plugin on the printed page. On the + * Macintosh, platformPrint is the printer port; on + * Windows, platformPrint is the handle to the printing + * device context. + */ + + /***** Insert NPP_Print code here *****\ + NPWindow* printWindow = + &(printInfo->print.embedPrint.window); + void* platformPrint = + printInfo->print.embedPrint.platformPrint; + \**************************************/ + } + } +} + +int16 NPP_HandleEvent(NPP instance, void* event) +{ + /*printf("NPP_HandleEvent()\n");*/ + + return GtkVNCXHandleEvent(instance, event); +} diff -r c49bf3e93ba1 -r b3a614359afb plugin/npunix.c --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/plugin/npunix.c Fri Jan 11 11:57:54 2008 +0000 @@ -0,0 +1,537 @@ +/* -*- Mode: C; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- + * + * ***** BEGIN LICENSE BLOCK ***** + * Version: MPL 1.1/GPL 2.0/LGPL 2.1 + * + * The contents of this file are subject to the Mozilla Public License Version + * 1.1 (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * http://www.mozilla.org/MPL/ + * + * Software distributed under the License is distributed on an "AS IS" basis, + * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License + * for the specific language governing rights and limitations under the + * License. + * + * The Original Code is mozilla.org code. + * + * The Initial Developer of the Original Code is + * Netscape Communications Corporation. + * Portions created by the Initial Developer are Copyright (C) 1998 + * the Initial Developer. All Rights Reserved. + * + * Contributor(s): + * Stephen Mak <smak sun com> + * + * Alternatively, the contents of this file may be used under the terms of + * either of the GNU General Public License Version 2 or later (the "GPL"), + * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"), + * in which case the provisions of the GPL or the LGPL are applicable instead + * of those above. If you wish to allow use of your version of this file only + * under the terms of either the GPL or the LGPL, and not to allow others to + * use your version of this file under the terms of the MPL, indicate your + * decision by deleting the provisions above and replace them with the notice + * and other provisions required by the GPL or the LGPL. If you do not delete + * the provisions above, a recipient may use your version of this file under + * the terms of any one of the MPL, the GPL or the LGPL. + * + * ***** END LICENSE BLOCK ***** */ + +/* + * npunix.c + * + * Netscape Client Plugin API + * - Wrapper function to interface with the Netscape Navigator + * + * dp Suresh <dp netscape com> + * + *---------------------------------------------------------------------- + * PLUGIN DEVELOPERS: + * YOU WILL NOT NEED TO EDIT THIS FILE. + *---------------------------------------------------------------------- + */ + +#define XP_UNIX 1 + +#include <stdio.h> +#include <npapi.h> +#include <npupp.h> + +#include <glib.h> /* just for G_GNUC_UNUSED */ + +/* + * Define PLUGIN_TRACE to have the wrapper functions print + * messages to stderr whenever they are called. + */ + +#ifdef PLUGIN_TRACE +#include <stdio.h> +#define PLUGINDEBUGSTR(msg) fprintf(stderr, "%s\n", msg) +#else +#define PLUGINDEBUGSTR(msg) +#endif + + +/*********************************************************************** + * + * Globals + * + ***********************************************************************/ + +static NPNetscapeFuncs gNetscapeFuncs; /* Netscape Function table */ + + +/*********************************************************************** + * + * Wrapper functions : plugin calling Netscape Navigator + * + * These functions let the plugin developer just call the APIs + * as documented and defined in npapi.h, without needing to know + * about the function table and call macros in npupp.h. + * + ***********************************************************************/ + +void +NPN_Version(int* plugin_major, int* plugin_minor, + int* netscape_major, int* netscape_minor) +{ + *plugin_major = NP_VERSION_MAJOR; + *plugin_minor = NP_VERSION_MINOR; + + /* Major version is in high byte */ + *netscape_major = gNetscapeFuncs.version >> 8; + /* Minor version is in low byte */ + *netscape_minor = gNetscapeFuncs.version & 0xFF; +} + +NPError +NPN_GetValue(NPP instance, NPNVariable variable, void *r_value) +{ + return CallNPN_GetValueProc(gNetscapeFuncs.getvalue, + instance, variable, r_value); +} + +NPError +NPN_SetValue(NPP instance, NPPVariable variable, void *value) +{ + return CallNPN_SetValueProc(gNetscapeFuncs.setvalue, + instance, variable, value); +} + +NPError +NPN_GetURL(NPP instance, const char* url, const char* window) +{ + return CallNPN_GetURLProc(gNetscapeFuncs.geturl, instance, url, window); +} + +NPError +NPN_GetURLNotify(NPP instance, const char* url, const char* window, void* notifyData) +{ + return CallNPN_GetURLNotifyProc(gNetscapeFuncs.geturlnotify, instance, url, window, notifyData); +} + +NPError +NPN_PostURL(NPP instance, const char* url, const char* window, + uint32 len, const char* buf, NPBool file) +{ + return CallNPN_PostURLProc(gNetscapeFuncs.posturl, instance, + url, window, len, buf, file); +} + +NPError +NPN_PostURLNotify(NPP instance, const char* url, const char* window, uint32 len, + const char* buf, NPBool file, void* notifyData) +{ + return CallNPN_PostURLNotifyProc(gNetscapeFuncs.posturlnotify, + instance, url, window, len, buf, file, notifyData); +} + +NPError +NPN_RequestRead(NPStream* stream, NPByteRange* rangeList) +{ + return CallNPN_RequestReadProc(gNetscapeFuncs.requestread, + stream, rangeList); +} + +NPError +NPN_NewStream(NPP instance, NPMIMEType type, const char *window, + NPStream** stream_ptr) +{ + return CallNPN_NewStreamProc(gNetscapeFuncs.newstream, instance, + type, window, stream_ptr); +} + +int32 +NPN_Write(NPP instance, NPStream* stream, int32 len, void* buffer) +{ + return CallNPN_WriteProc(gNetscapeFuncs.write, instance, + stream, len, buffer); +} + +NPError +NPN_DestroyStream(NPP instance, NPStream* stream, NPError reason) +{ + return CallNPN_DestroyStreamProc(gNetscapeFuncs.destroystream, + instance, stream, reason); +} + +void +NPN_Status(NPP instance, const char* message) +{ + CallNPN_StatusProc(gNetscapeFuncs.status, instance, message); +} + +const char* +NPN_UserAgent(NPP instance) +{ + return CallNPN_UserAgentProc(gNetscapeFuncs.uagent, instance); +} + +void* +NPN_MemAlloc(uint32 size) +{ + return CallNPN_MemAllocProc(gNetscapeFuncs.memalloc, size); +} + +void NPN_MemFree(void* ptr) +{ + CallNPN_MemFreeProc(gNetscapeFuncs.memfree, ptr); +} + +uint32 NPN_MemFlush(uint32 size) +{ + return CallNPN_MemFlushProc(gNetscapeFuncs.memflush, size); +} + +void NPN_ReloadPlugins(NPBool reloadPages) +{ + CallNPN_ReloadPluginsProc(gNetscapeFuncs.reloadplugins, reloadPages); +} + +#ifdef OJI +JRIEnv* NPN_GetJavaEnv() +{ + return CallNPN_GetJavaEnvProc(gNetscapeFuncs.getJavaEnv); +} + +jref NPN_GetJavaPeer(NPP instance) +{ + return CallNPN_GetJavaPeerProc(gNetscapeFuncs.getJavaPeer, + instance); +} +#endif + +void +NPN_InvalidateRect(NPP instance, NPRect *invalidRect) +{ + CallNPN_InvalidateRectProc(gNetscapeFuncs.invalidaterect, instance, + invalidRect); +} + +void +NPN_InvalidateRegion(NPP instance, NPRegion invalidRegion) +{ + CallNPN_InvalidateRegionProc(gNetscapeFuncs.invalidateregion, instance, + invalidRegion); +} + +void +NPN_ForceRedraw(NPP instance) +{ + CallNPN_ForceRedrawProc(gNetscapeFuncs.forceredraw, instance); +} + +void NPN_PushPopupsEnabledState(NPP instance, NPBool enabled) +{ + CallNPN_PushPopupsEnabledStateProc(gNetscapeFuncs.pushpopupsenabledstate, + instance, enabled); +} + +void NPN_PopPopupsEnabledState(NPP instance) +{ + CallNPN_PopPopupsEnabledStateProc(gNetscapeFuncs.poppopupsenabledstate, + instance); +} + + + +/*********************************************************************** + * + * Wrapper functions : Netscape Navigator -> plugin + * + * These functions let the plugin developer just create the APIs + * as documented and defined in npapi.h, without needing to + * install those functions in the function table or worry about + * setting up globals for 68K plugins. + * + ***********************************************************************/ + +static NPError +Private_New(NPMIMEType pluginType, NPP instance, uint16 mode, + int16 argc, char* argn[], char* argv[], NPSavedData* saved) +{ + NPError ret; + PLUGINDEBUGSTR("New"); + ret = NPP_New(pluginType, instance, mode, argc, argn, argv, saved); + return ret; +} + +static NPError +Private_Destroy(NPP instance, NPSavedData** save) +{ + PLUGINDEBUGSTR("Destroy"); + return NPP_Destroy(instance, save); +} + +static NPError +Private_SetWindow(NPP instance, NPWindow* window) +{ + NPError err; + PLUGINDEBUGSTR("SetWindow"); + err = NPP_SetWindow(instance, window); + return err; +} + +static NPError +Private_NewStream(NPP instance G_GNUC_UNUSED, NPMIMEType type G_GNUC_UNUSED, + NPStream* stream G_GNUC_UNUSED, + NPBool seekable G_GNUC_UNUSED, uint16* stype G_GNUC_UNUSED) +{ + NPError err = NPERR_NO_ERROR; + PLUGINDEBUGSTR("NewStream"); +/* err = NPP_NewStream(instance, type, stream, seekable, stype);*/ + return err; +} + +static int32 +Private_WriteReady(NPP instance, NPStream* stream) +{ + unsigned int result; + PLUGINDEBUGSTR("WriteReady"); + result = NPP_WriteReady(instance, stream); + return result; +} + +static int32 +Private_Write(NPP instance, NPStream* stream, int32 offset, int32 len, + void* buffer) +{ + unsigned int result; + PLUGINDEBUGSTR("Write"); + result = NPP_Write(instance, stream, offset, len, buffer); + return result; +} + +static void +Private_StreamAsFile(NPP instance, NPStream* stream, const char* fname) +{ + PLUGINDEBUGSTR("StreamAsFile"); + NPP_StreamAsFile(instance, stream, fname); +} + + +static NPError +Private_DestroyStream(NPP instance, NPStream* stream, NPError reason) +{ + NPError err; + PLUGINDEBUGSTR("DestroyStream"); + err = NPP_DestroyStream(instance, stream, reason); + return err; +} + +static void +Private_URLNotify(NPP instance, const char* url, + NPReason reason, void* notifyData) + +{ + PLUGINDEBUGSTR("URLNotify"); + NPP_URLNotify(instance, url, reason, notifyData); +} + +static NPError +Private_GetValue(void *instance, NPPVariable variable, void *result) +{ + NPError rv = NPP_GetValue(instance, variable, result); + return rv; +} + +static void +Private_Print(NPP instance, NPPrint* platformPrint) +{ + PLUGINDEBUGSTR("Print"); + NPP_Print(instance, platformPrint); +} + +#ifdef OJI +static JRIGlobalRef +Private_GetJavaClass(void) +{ + jref clazz = NPP_GetJavaClass(); + if (clazz) { + JRIEnv* env = NPN_GetJavaEnv(); + return JRI_NewGlobalRef(env, clazz); + } + return NULL; +} +#endif + +static int16 +Private_HandleEvent(NPP instance, void* event) +{ + return NPP_HandleEvent(instance, event); +} + +/*********************************************************************** + * + * These functions are located automagically by netscape. + * + ***********************************************************************/ + +/* + * NP_GetMIMEDescription + * - Netscape needs to know about this symbol + * - Netscape uses the return value to identify when an object instance + * of this plugin should be created. + */ +char * +NP_GetMIMEDescription(void) +{ + return NPP_GetMIMEDescription(); +} + +/* + * NP_GetValue [optional] + * - Netscape needs to know about this symbol. + * - Interfaces with plugin to get values for predefined variables + * that the navigator needs. + */ +NPError +NP_GetValue(void* future, NPPVariable variable, void *value) +{ + return NPP_GetValue(future, variable, value); +} + +/* + * NP_Initialize + * - Netscape needs to know about this symbol. + * - It calls this function after looking up its symbol before it + * is about to create the first ever object of this kind. + * + * PARAMETERS + * nsTable - The netscape function table. If developers just use these + * wrappers, they dont need to worry about all these function + * tables. + * RETURN + * pluginFuncs + * - This functions needs to fill the plugin function table + * pluginFuncs and return it. Netscape Navigator plugin + * library will use this function table to call the plugin. + * + */ +NPError +NP_Initialize(NPNetscapeFuncs* nsTable, NPPluginFuncs* pluginFuncs) +{ + NPError err = NPERR_NO_ERROR; + + PLUGINDEBUGSTR("NP_Initialize"); + + /* validate input parameters */ + + if ((nsTable == NULL) || (pluginFuncs == NULL)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + + /* + * Check the major version passed in Netscape's function table. + * We won't load if the major version is newer than what we expect. + * Also check that the function tables passed in are big enough for + * all the functions we need (they could be bigger, if Netscape added + * new APIs, but that's OK with us -- we'll just ignore them). + * + */ + + if (err == NPERR_NO_ERROR) { + if ((nsTable->version >> 8) > NP_VERSION_MAJOR) + err = NPERR_INCOMPATIBLE_VERSION_ERROR; + if (nsTable->size < sizeof(NPNetscapeFuncs)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + if (pluginFuncs->size < sizeof(NPPluginFuncs)) + err = NPERR_INVALID_FUNCTABLE_ERROR; + } + + + if (err == NPERR_NO_ERROR) { + /* + * Copy all the fields of Netscape function table into our + * copy so we can call back into Netscape later. Note that + * we need to copy the fields one by one, rather than assigning + * the whole structure, because the Netscape function table + * could actually be bigger than what we expect. + */ + gNetscapeFuncs.version = nsTable->version; + gNetscapeFuncs.size = nsTable->size; + gNetscapeFuncs.posturl = nsTable->posturl; + gNetscapeFuncs.geturl = nsTable->geturl; + gNetscapeFuncs.geturlnotify = nsTable->geturlnotify; + gNetscapeFuncs.requestread = nsTable->requestread; + gNetscapeFuncs.newstream = nsTable->newstream; + gNetscapeFuncs.write = nsTable->write; + gNetscapeFuncs.destroystream = nsTable->destroystream; + gNetscapeFuncs.status = nsTable->status; + gNetscapeFuncs.uagent = nsTable->uagent; + gNetscapeFuncs.memalloc = nsTable->memalloc; + gNetscapeFuncs.memfree = nsTable->memfree; + gNetscapeFuncs.memflush = nsTable->memflush; + gNetscapeFuncs.reloadplugins = nsTable->reloadplugins; +#ifdef OJI + gNetscapeFuncs.getJavaEnv = nsTable->getJavaEnv; + gNetscapeFuncs.getJavaPeer = nsTable->getJavaPeer; +#endif + gNetscapeFuncs.getvalue = nsTable->getvalue; + gNetscapeFuncs.setvalue = nsTable->setvalue; + gNetscapeFuncs.pushpopupsenabledstate = nsTable->pushpopupsenabledstate; + gNetscapeFuncs.poppopupsenabledstate = nsTable->poppopupsenabledstate; + + /* + * Set up the plugin function table that Netscape will use to + * call us. Netscape needs to know about our version and size + * and have a UniversalProcPointer for every function we + * implement. + */ + pluginFuncs->version = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR; + pluginFuncs->size = sizeof(NPPluginFuncs); + pluginFuncs->newp = NewNPP_NewProc(Private_New); + pluginFuncs->destroy = NewNPP_DestroyProc(Private_Destroy); + pluginFuncs->setwindow = NewNPP_SetWindowProc(Private_SetWindow); + pluginFuncs->newstream = NewNPP_NewStreamProc(Private_NewStream); + pluginFuncs->destroystream = NewNPP_DestroyStreamProc(Private_DestroyStream); + pluginFuncs->asfile = NewNPP_StreamAsFileProc(Private_StreamAsFile); + pluginFuncs->writeready = NewNPP_WriteReadyProc(Private_WriteReady); + pluginFuncs->write = NewNPP_WriteProc(Private_Write); + pluginFuncs->print = NewNPP_PrintProc(Private_Print); + pluginFuncs->urlnotify = NewNPP_URLNotifyProc(Private_URLNotify); + pluginFuncs->getvalue = NewNPP_GetValueProc(Private_GetValue); + pluginFuncs->event = NewNPP_HandleEventProc(Private_HandleEvent); +#ifdef OJI + pluginFuncs->javaClass = Private_GetJavaClass(); +#endif + + err = NPP_Initialize(); + } + + return err; +} + +/* + * NP_Shutdown [optional] + * - Netscape needs to know about this symbol. + * - It calls this function after looking up its symbol after + * the last object of this kind has been destroyed. + * + */ +NPError +NP_Shutdown(void) +{ + PLUGINDEBUGSTR("NP_Shutdown"); + NPP_Shutdown(); + return NPERR_NO_ERROR; +}
Attachment:
smime.p7s
Description: S/MIME Cryptographic Signature