1 /*

     2  * Copyright (C) 2006, 2007 Apple Inc. All rights reserved.

     3  * Copyright (C) 2008 Zan Dobersek <zandobersek@gmail.com>

     4  * Copyright (C) 2009 Holger Hans Peter Freyther

     5  *

     6  * Redistribution and use in source and binary forms, with or without

     7  * modification, are permitted provided that the following conditions

     8  * are met:

     9  * 1. Redistributions of source code must retain the above copyright

    10  *    notice, this list of conditions and the following disclaimer.

    11  * 2. Redistributions in binary form must reproduce the above copyright

    12  *    notice, this list of conditions and the following disclaimer in the

    13  *    documentation and/or other materials provided with the distribution.

    14  *

    15  * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY

    16  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE

    17  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR

    18  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL APPLE INC. OR

    19  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,

    20  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,

    21  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR

    22  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY

    23  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT

    24  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE

    25  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

    26  */

    27 

    28 #include "config.h"

    29 #include "PluginObject.h"

    30 

    31 #include "npapi.h"

    32 #include "npruntime.h"

    33 #include "npfunctions.h"

    34 

    35 #include <stdarg.h>

    36 #include <stdio.h>

    37 #include <string.h>

    38 #include <stdlib.h>

    39 #include <X11/Xlib.h>

    40 

    41 extern "C" {

    42     NPError NP_Initialize (NPNetscapeFuncs *aMozillaVTable, NPPluginFuncs *aPluginVTable);

    43     NPError NP_Shutdown(void);

    44     NPError NP_GetValue(void *future, NPPVariable variable, void *value);

    45     char* NP_GetMIMEDescription(void);

    46 }

    47 

    48 static void executeScript(const PluginObject* obj, const char* script);

    49 

    50 static NPError

    51 webkit_test_plugin_new_instance(NPMIMEType /*mimetype*/,

    52                                 NPP instance,

    53                                 uint16_t /*mode*/,

    54                                 int16_t argc,

    55                                 char *argn[],

    56                                 char *argv[],

    57                                 NPSavedData* /*savedData*/)

    58 {

    59     if (browser->version >= 14) {

    60         PluginObject* obj = (PluginObject*)browser->createobject(instance, getPluginClass());

    61         instance->pdata = obj;

    62 

    63         for (int i = 0; i < argc; i++) {

    64             if (strcasecmp(argn[i], "onstreamload") == 0 && !obj->onStreamLoad)

    65                 obj->onStreamLoad = strdup(argv[i]);

    66             else if (strcasecmp(argn[i], "onStreamDestroy") == 0 && !obj->onStreamDestroy)

    67                 obj->onStreamDestroy = strdup(argv[i]);

    68             else if (strcasecmp(argn[i], "onURLNotify") == 0 && !obj->onURLNotify)

    69                 obj->onURLNotify = strdup(argv[i]);

    70             else if (strcasecmp(argn[i], "src") == 0 &&

    71                      strcasecmp(argv[i], "data:application/x-webkit-test-netscape,returnerrorfromnewstream") == 0)

    72                 obj->returnErrorFromNewStream = TRUE;

    73             else if (strcasecmp(argn[i], "logfirstsetwindow") == 0)

    74                 obj->logSetWindow = TRUE;

    75             else if (strcasecmp(argn[i], "testnpruntime") == 0)

    76                 testNPRuntime(instance);

    77             else if (strcasecmp(argn[i], "logSrc") == 0) {

    78                 for (int i = 0; i < argc; i++)

    79                     if (strcasecmp(argn[i], "src") == 0)

    80                         pluginLog(instance, "src: %s", argv[i]);

    81             } else if (strcasecmp(argn[i], "cleardocumentduringnew") == 0)

    82                 executeScript(obj, "document.body.innerHTML = ''");

    83             else if (!strcasecmp(argn[i], "ondestroy"))

    84                 obj->onDestroy = strdup(argv[i]);

    85             else if (strcasecmp(argn[i], "testdocumentopenindestroystream") == 0)

    86                 obj->testDocumentOpenInDestroyStream = TRUE;

    87             else if (strcasecmp(argn[i], "testwindowopen") == 0)

    88                 obj->testWindowOpen = TRUE;

    89             else if (strcasecmp(argn[i], "onSetWindow") == 0 && !obj->onSetWindow)

    90                 obj->onSetWindow = strdup(argv[i]);

    91         }

    92 

    93         browser->getvalue(instance, NPNVprivateModeBool, (void *)&obj->cachedPrivateBrowsingMode);

    94     }

    95 

    96     return NPERR_NO_ERROR;

    97 }

    98 

    99 static NPError

   100 webkit_test_plugin_destroy_instance(NPP instance, NPSavedData** /*save*/)

   101 {

   102     PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   103     if (obj) {

   104         if (obj->onDestroy) {

   105             executeScript(obj, obj->onDestroy);

   106             free(obj->onDestroy);

   107         }

   108 

   109         if (obj->onStreamLoad)

   110             free(obj->onStreamLoad);

   111 

   112         if (obj->onStreamDestroy)

   113             free(obj->onStreamDestroy);

   114 

   115         if (obj->onURLNotify)

   116             free(obj->onURLNotify);

   117 

   118         if (obj->logDestroy)

   119             pluginLog(instance, "NPP_Destroy");

   120 

   121         if (obj->onSetWindow)

   122             free(obj->onSetWindow);

   123 

   124         browser->releaseobject(&obj->header);

   125     }

   126 

   127     return NPERR_NO_ERROR;

   128 }

   129 

   130 static NPError

   131 webkit_test_plugin_set_window(NPP instance, NPWindow *window)

   132 {

   133     PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   134 

   135     if (obj) {

   136         obj->lastWindow = *window;

   137 

   138         if (obj->logSetWindow) {

   139             pluginLog(instance, "NPP_SetWindow: %d %d", (int)window->width, (int)window->height);

   140             obj->logSetWindow = false;

   141         }

   142         if (obj->onSetWindow)

   143             executeScript(obj, obj->onSetWindow);

   144 

   145         if (obj->testWindowOpen) {

   146             testWindowOpen(instance);

   147             obj->testWindowOpen = FALSE;

   148         }

   149 

   150     }

   151 

   152     return NPERR_NO_ERROR;

   153 }

   154 

   155 static void executeScript(const PluginObject* obj, const char* script)

   156 {

   157     NPObject *windowScriptObject;

   158     browser->getvalue(obj->npp, NPNVWindowNPObject, &windowScriptObject);

   159 

   160     NPString npScript;

   161     npScript.UTF8Characters = script;

   162     npScript.UTF8Length = strlen(script);

   163 

   164     NPVariant browserResult;

   165     browser->evaluate(obj->npp, windowScriptObject, &npScript, &browserResult);

   166     browser->releasevariantvalue(&browserResult);

   167 }

   168 

   169 static NPError

   170 webkit_test_plugin_new_stream(NPP instance,

   171                               NPMIMEType /*type*/,

   172                               NPStream *stream,

   173                               NPBool /*seekable*/,

   174                               uint16_t* stype)

   175 {

   176     PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   177     obj->stream = stream;

   178     *stype = NP_NORMAL;

   179 

   180     if (obj->returnErrorFromNewStream)

   181         return NPERR_GENERIC_ERROR;

   182 

   183     if (browser->version >= NPVERS_HAS_RESPONSE_HEADERS)

   184         notifyStream(obj, stream->url, stream->headers);

   185 

   186     if (obj->onStreamLoad)

   187         executeScript(obj, obj->onStreamLoad);

   188 

   189     return NPERR_NO_ERROR;

   190 }

   191 

   192 static NPError

   193 webkit_test_plugin_destroy_stream(NPP instance, NPStream* /*stream*/, NPError reason)

   194 {

   195     PluginObject* obj = (PluginObject*)instance->pdata;

   196 

   197     if (obj->onStreamDestroy) {

   198         NPObject* windowObject = 0;

   199         NPError error = browser->getvalue(instance, NPNVWindowNPObject, &windowObject);

   200         

   201         if (error == NPERR_NO_ERROR) {

   202             NPVariant onStreamDestroyVariant;

   203             if (browser->getproperty(instance, windowObject, browser->getstringidentifier(obj->onStreamDestroy), &onStreamDestroyVariant)) {

   204                 if (NPVARIANT_IS_OBJECT(onStreamDestroyVariant)) {

   205                     NPObject* onStreamDestroyFunction = NPVARIANT_TO_OBJECT(onStreamDestroyVariant);

   206 

   207                     NPVariant reasonVariant;

   208                     INT32_TO_NPVARIANT(reason, reasonVariant);

   209 

   210                     NPVariant result;

   211                     browser->invokeDefault(instance, onStreamDestroyFunction, &reasonVariant, 1, &result);

   212                     browser->releasevariantvalue(&result);

   213                 }

   214                 browser->releasevariantvalue(&onStreamDestroyVariant);

   215             }

   216             browser->releaseobject(windowObject);

   217         }

   218     }

   219 

   220     if (obj->testDocumentOpenInDestroyStream) {

   221         testDocumentOpen(instance);

   222         obj->testDocumentOpenInDestroyStream = FALSE;

   223     }

   224 

   225     return NPERR_NO_ERROR;

   226 }

   227 

   228 static void

   229 webkit_test_plugin_stream_as_file(NPP /*instance*/, NPStream* /*stream*/, const char* /*fname*/)

   230 {

   231 }

   232 

   233 static int32_t

   234 webkit_test_plugin_write_ready(NPP /*instance*/, NPStream* /*stream*/)

   235 {

   236     return 4096;

   237 }

   238 

   239 static int32_t

   240 webkit_test_plugin_write(NPP instance,

   241                          NPStream* /*stream*/,

   242                          int32_t /*offset*/,

   243                          int32_t len,

   244                          void* /*buffer*/)

   245 {

   246     PluginObject* obj = (PluginObject*)instance->pdata;

   247 

   248     if (obj->returnNegativeOneFromWrite)

   249         return -1;

   250 

   251     return len;

   252 }

   253 

   254 static void

   255 webkit_test_plugin_print(NPP /*instance*/, NPPrint* /*platformPrint*/)

   256 {

   257 }

   258 

   259 static int16_t

   260 webkit_test_plugin_handle_event(NPP instance, void* event)

   261 {

   262     PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   263     if (!obj->eventLogging)

   264         return 0;

   265 

   266     XEvent* evt = static_cast<XEvent*>(event);

   267     pluginLog(instance, "event %d", evt->type);

   268 

   269     return 0;

   270 }

   271 

   272 static void

   273 webkit_test_plugin_url_notify(NPP instance, const char* url, NPReason reason, void* notifyData)

   274 {

   275     PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   276 

   277     if (obj->onURLNotify)

   278         executeScript(obj, obj->onURLNotify);

   279 

   280     handleCallback(obj, url, reason, notifyData);

   281 }

   282 

   283 static NPError

   284 webkit_test_plugin_get_value(NPP instance, NPPVariable variable, void *value)

   285 {

   286     NPError err = NPERR_NO_ERROR;

   287 

   288     switch (variable) {

   289         case NPPVpluginNameString:

   290             *((char **)value) = const_cast<char*>("WebKit Test PlugIn");

   291             break;

   292         case NPPVpluginDescriptionString:

   293             *((char **)value) = const_cast<char*>("Simple Netscape plug-in that handles test content for WebKit");

   294             break;

   295         case NPPVpluginNeedsXEmbed:

   296             *((NPBool *)value) = TRUE;

   297             break;

   298         case NPPVpluginScriptableIID:

   299         case NPPVpluginScriptableInstance:

   300         case NPPVpluginScriptableNPObject:

   301             err = NPERR_GENERIC_ERROR;

   302             break;

   303         default:

   304             fprintf(stderr, "Unhandled variable\n");

   305             err = NPERR_GENERIC_ERROR;

   306             break;

   307     }

   308 

   309     if (variable == NPPVpluginScriptableNPObject) {

   310         void **v = (void **)value;

   311         PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   312         browser->retainobject((NPObject *)obj);

   313         *v = obj;

   314         err = NPERR_NO_ERROR;

   315     }

   316 

   317     return err;

   318 }

   319 

   320 static NPError

   321 webkit_test_plugin_set_value(NPP instance, NPNVariable variable, void* value)

   322 {

   323     PluginObject* obj = static_cast<PluginObject*>(instance->pdata);

   324 

   325     switch (variable) {

   326         case NPNVprivateModeBool:

   327             obj->cachedPrivateBrowsingMode = *(NPBool*)value;

   328             return NPERR_NO_ERROR;

   329         default:

   330             return NPERR_GENERIC_ERROR;

   331     }

   332 }

   333 

   334 char *

   335 NP_GetMIMEDescription(void)

   336 {

   337     return const_cast<char*>("application/x-webkit-test-netscape:testnetscape:test netscape content");

   338 }

   339 

   340 NPError

   341 NP_Initialize (NPNetscapeFuncs *aMozillaVTable, NPPluginFuncs *aPluginVTable)

   342 {

   343     if (aMozillaVTable == NULL || aPluginVTable == NULL)

   344         return NPERR_INVALID_FUNCTABLE_ERROR;

   345 

   346     if ((aMozillaVTable->version >> 8) > NP_VERSION_MAJOR)

   347         return NPERR_INCOMPATIBLE_VERSION_ERROR;

   348 

   349     if (aPluginVTable->size < sizeof (NPPluginFuncs))

   350         return NPERR_INVALID_FUNCTABLE_ERROR;

   351 

   352     browser = aMozillaVTable;

   353 

   354         aPluginVTable->size           = sizeof (NPPluginFuncs);

   355         aPluginVTable->version        = (NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR;

   356         aPluginVTable->newp           = webkit_test_plugin_new_instance;

   357         aPluginVTable->destroy        = webkit_test_plugin_destroy_instance;

   358         aPluginVTable->setwindow      = webkit_test_plugin_set_window;

   359         aPluginVTable->newstream      = webkit_test_plugin_new_stream;

   360         aPluginVTable->destroystream  = webkit_test_plugin_destroy_stream;

   361         aPluginVTable->asfile         = webkit_test_plugin_stream_as_file;

   362         aPluginVTable->writeready     = webkit_test_plugin_write_ready;

   363         aPluginVTable->write          = webkit_test_plugin_write;

   364         aPluginVTable->print          = webkit_test_plugin_print;

   365         aPluginVTable->event          = webkit_test_plugin_handle_event;

   366         aPluginVTable->urlnotify      = webkit_test_plugin_url_notify;

   367         aPluginVTable->javaClass      = NULL;

   368         aPluginVTable->getvalue       = webkit_test_plugin_get_value;

   369         aPluginVTable->setvalue       = webkit_test_plugin_set_value;

   370 

   371     return NPERR_NO_ERROR;

   372 }

   373 

   374 NPError

   375 NP_Shutdown(void)

   376 {

   377     return NPERR_NO_ERROR;

   378 }

   379 

   380 NPError

   381 NP_GetValue(void* /*future*/, NPPVariable variable, void *value)

   382 {

   383     return webkit_test_plugin_get_value(NULL, variable, value);

   384 }