plugin/plugin-entry.cpp

   1 /*
   2  * plugin-entry.cpp: MoonLight browser plugin.
   3  *
   4  * Contact:
   5  *   Moonlight List (moonlight-list@lists.ximian.com)
   6  *
   7  * Copyright 2007 Novell, Inc. (http://www.novell.com)
   8  *
   9  * See the LICENSE file included with the distribution for details.
  10  *
  11  */
  12
  13 #include <config.h>
  14 #include <stdio.h>
  15 #include <string.h>
  16
  17 #include "moonlight.h"
  18
  19 #include "npapi.h"
  20 #include "npfunctions.h"
  21
  22 // Global function table
  23 static NPNetscapeFuncs MozillaFuncs;
  24
  25 /*** Wrapper functions ********************************************************/
  26
  27 void
  28 NPN_Version (int *plugin_major, int *plugin_minor, int *netscape_major, int *netscape_minor)
  29 {
  30         *plugin_major = NP_VERSION_MAJOR;
  31         *plugin_minor = NP_VERSION_MINOR;
  32         *netscape_major = MozillaFuncs.version >> 8;
  33         *netscape_minor = MozillaFuncs.version & 0xFF;
  34 }
  35
  36 NPError
  37 NPN_GetValue (NPP instance, NPNVariable variable, void *r_value)
  38 {
  39         return MozillaFuncs.getvalue (instance, variable, r_value);
  40 }
  41
  42 NPError
  43 NPN_SetValue (NPP instance, NPPVariable variable, void *value)
  44 {
  45         return MozillaFuncs.setvalue (instance, variable, value);
  46 }
  47
  48 NPError
  49 NPN_GetURL (NPP instance, const char *url, const char *window)
  50 {
  51         return MozillaFuncs.geturl (instance, url, window);
  52 }
  53
  54 NPError
  55 NPN_GetURLNotify (NPP instance, const char *url,
  56                   const char *window, void *notifyData)
  57 {
  58         return MozillaFuncs.geturlnotify (instance,
  59                                           url, window, notifyData);
  60 }
  61
  62 NPError
  63 NPN_PostURL (NPP instance, const char *url, const char *window,
  64              uint32_t len, const char *buf, NPBool file)
  65 {
  66         return MozillaFuncs.posturl (instance, url, window, len, buf, file);
  67 }
  68
  69 NPError
  70 NPN_PostURLNotify (NPP instance, const char *url, const char *window,
  71                    uint32_t len, const char *buf, NPBool file, void *notifyData)
  72 {
  73         return MozillaFuncs.posturlnotify (instance, url,
  74                                            window, len, buf, file, notifyData);
  75 }
  76
  77 NPError
  78 NPN_RequestRead (NPStream *stream, NPByteRange *rangeList)
  79 {
  80         return MozillaFuncs.requestread (stream, rangeList);
  81 }
  82
  83 NPError
  84 NPN_NewStream (NPP instance, NPMIMEType type, const char *window, NPStream **stream_ptr)
  85 {
  86         return MozillaFuncs.newstream (instance,
  87                                        type, window, stream_ptr);
  88 }
  89
  90 int32_t
  91 NPN_Write (NPP instance, NPStream *stream, int32_t len, void *buffer)
  92 {
  93         return MozillaFuncs.write (instance, stream, len, buffer);
  94 }
  95
  96 NPError
  97 NPN_DestroyStream (NPP instance, NPStream *stream, NPError reason)
  98 {
  99         return MozillaFuncs.destroystream (instance, stream, reason);
 100 }
 101
 102 void NPN_Status (NPP instance, const char *message)
 103 {
 104         if (strstr (NPN_UserAgent (instance), "Firefox"))
 105                 MozillaFuncs.status (instance, message);
 106 }
 107
 108 const char *
 109 NPN_UserAgent (NPP instance)
 110 {
 111         return MozillaFuncs.uagent (instance);
 112 }
 113
 114 void *
 115 NPN_MemAlloc (uint32_t size)
 116 {
 117         return MozillaFuncs.memalloc (size);
 118 }
 119
 120 void
 121 NPN_MemFree (void *ptr)
 122 {
 123         MozillaFuncs.memfree (ptr);
 124 }
 125
 126 uint32_t
 127 NPN_MemFlush (uint32_t size)
 128 {
 129         return MozillaFuncs.memflush (size);
 130 }
 131
 132 void
 133 NPN_ReloadPlugins (NPBool reloadPages)
 134 {
 135         MozillaFuncs.reloadplugins (reloadPages);
 136 }
 137
 138 void
 139 NPN_InvalidateRect (NPP instance, NPRect *invalidRect)
 140 {
 141         MozillaFuncs.invalidaterect (instance, invalidRect);
 142 }
 143
 144 void
 145 NPN_InvalidateRegion (NPP instance, NPRegion invalidRegion)
 146 {
 147         MozillaFuncs.invalidateregion (instance, invalidRegion);
 148 }
 149
 150 void
 151 NPN_ForceRedraw (NPP instance)
 152 {
 153         MozillaFuncs.forceredraw (instance);
 154 }
 155
 156 /*** Runtime support **********************************************************/
 157
 158 NPIdentifier
 159 NPN_GetStringIdentifier (const NPUTF8 *name)
 160 {
 161         return MozillaFuncs.getstringidentifier (name);
 162 }
 163
 164 void
 165 NPN_GetStringIdentifiers (const NPUTF8 **names, int32_t nameCount, NPIdentifier *identifiers)
 166 {
 167         MozillaFuncs.getstringidentifiers (names, nameCount, identifiers);
 168 }
 169
 170 NPIdentifier
 171 NPN_GetIntIdentifier (int32_t intid)
 172 {
 173         return MozillaFuncs.getintidentifier (intid);
 174 }
 175
 176 bool
 177 NPN_IdentifierIsString (NPIdentifier identifier)
 178 {
 179         return MozillaFuncs.identifierisstring (identifier);
 180 }
 181
 182 NPUTF8 *
 183 NPN_UTF8FromIdentifier (NPIdentifier identifier)
 184 {
 185         return MozillaFuncs.utf8fromidentifier (identifier);
 186 }
 187
 188 int32_t
 189 NPN_IntFromIdentifier (NPIdentifier identifier)
 190 {
 191         return MozillaFuncs.intfromidentifier (identifier);
 192 }
 193
 194 NPObject *
 195 NPN_CreateObject (NPP npp, NPClass *aClass)
 196 {
 197         return MozillaFuncs.createobject (npp, aClass);
 198 }
 199
 200 NPObject *
 201 NPN_RetainObject (NPObject *obj)
 202 {
 203         return MozillaFuncs.retainobject (obj);
 204 }
 205
 206 void
 207 NPN_ReleaseObject (NPObject *obj)
 208 {
 209         return MozillaFuncs.releaseobject (obj);
 210 }
 211
 212 bool
 213 NPN_Invoke (NPP npp, NPObject *obj, NPIdentifier methodName,
 214             const NPVariant *args, uint32_t argCount, NPVariant *result)
 215 {
 216         return MozillaFuncs.invoke (npp, obj, methodName, args, argCount, result);
 217 }
 218
 219 bool
 220 NPN_InvokeDefault (NPP npp, NPObject *obj, const NPVariant *args,
 221                    uint32_t argCount, NPVariant *result)
 222 {
 223         return MozillaFuncs.invokeDefault (npp, obj, args, argCount, result);
 224 }
 225
 226 bool
 227 NPN_Evaluate (NPP npp, NPObject *obj, NPString *script, NPVariant *result)
 228 {
 229         return MozillaFuncs.evaluate (npp, obj, script, result);
 230 }
 231
 232 bool
 233 NPN_GetProperty (NPP npp, NPObject *obj, NPIdentifier propertyName, NPVariant *result)
 234 {
 235         return MozillaFuncs.getproperty (npp, obj, propertyName, result);
 236 }
 237
 238 bool
 239 NPN_SetProperty (NPP npp, NPObject *obj, NPIdentifier propertyName, const NPVariant *value)
 240 {
 241         return MozillaFuncs.setproperty (npp, obj, propertyName, value);
 242 }
 243
 244 bool
 245 NPN_RemoveProperty (NPP npp, NPObject *obj, NPIdentifier propertyName)
 246 {
 247         return MozillaFuncs.removeproperty (npp, obj, propertyName);
 248 }
 249
 250 bool
 251 NPN_HasProperty (NPP npp, NPObject *obj, NPIdentifier propertyName)
 252 {
 253         return MozillaFuncs.hasproperty (npp, obj, propertyName);
 254 }
 255
 256 bool
 257 NPN_Enumerate (NPP npp, NPObject *obj, NPIdentifier **values,
 258                uint32_t *count)
 259 {
 260         return MozillaFuncs.enumerate (npp, obj, values, count);
 261 }
 262
 263 bool
 264 NPN_HasMethod (NPP npp, NPObject *obj, NPIdentifier methodName)
 265 {
 266         return MozillaFuncs.hasmethod (npp, obj, methodName);
 267 }
 268
 269 void
 270 NPN_ReleaseVariantValue (NPVariant *variant)
 271 {
 272         MozillaFuncs.releasevariantvalue (variant);
 273 }
 274
 275 void NPN_SetException (NPObject *obj, const NPUTF8 *message)
 276 {
 277         MozillaFuncs.setexception (obj, message);
 278 }
 279
 280 /*** Popup support ************************************************************/
 281
 282 void
 283 NPN_PushPopupsEnabledState (NPP instance, NPBool enabled)
 284 {
 285         MozillaFuncs.pushpopupsenabledstate (instance, enabled);
 286 }
 287
 288 void
 289 NPN_PopPopupsEnabledState (NPP instance)
 290 {
 291         MozillaFuncs.poppopupsenabledstate (instance);
 292 }
 293
 294 /*** These functions are located automagically by mozilla *********************/
 295
 296 char *
 297 LOADER_RENAMED_SYM(NP_GetMIMEDescription) (void)
 298 {
 299         return NPP_GetMIMEDescription ();
 300 }
 301
 302 NPError
 303 LOADER_RENAMED_SYM(NP_GetValue) (void *future, NPPVariable variable, void *value)
 304 {
 305         return NPP_GetValue ((NPP) future, variable, value);
 306 }
 307
 308 NPError OSCALL
 309 LOADER_RENAMED_SYM(NP_Initialize) (NPNetscapeFuncs *mozilla_funcs, NPPluginFuncs *plugin_funcs)
 310 {
 311         if (mozilla_funcs == NULL || plugin_funcs == NULL)
 312                 return NPERR_INVALID_FUNCTABLE_ERROR;
 313
 314         // remove these checks, since we compile against trunk firefox
 315         // np*.h now, sizeof (struct) will be > if we run against
 316         // firefox 2.
 317         //
 318         // everything is ok, though.  we just need to check against
 319         // the NPVERS_HAS_* defines when filling in the function
 320         // table.
 321 #if 0
 322         if (mozilla_funcs->size < sizeof (NPNetscapeFuncs))
 323                 return NPERR_INVALID_FUNCTABLE_ERROR;
 324
 325
 326         if (plugin_funcs->size < sizeof (NPPluginFuncs))
 327                 return NPERR_INVALID_FUNCTABLE_ERROR;
 328 #endif
 329
 330         if ((mozilla_funcs->version >> 8) > NP_VERSION_MAJOR)
 331                 return NPERR_INCOMPATIBLE_VERSION_ERROR;
 332
 333         NPError err = NPERR_NO_ERROR;
 334         guint32 supportsXEmbed = FALSE; // NPBool + padding
 335         NPNToolkitType toolkit = (NPNToolkitType) 0;
 336
 337         // XEmbed ?
 338         err = mozilla_funcs->getvalue (NULL,
 339                                        NPNVSupportsXEmbedBool,
 340                                        (void *) &supportsXEmbed);
 341
 342         if (err != NPERR_NO_ERROR || supportsXEmbed != TRUE)
 343                 g_warning ("It appears your browser may not support XEmbed");
 344
 345         // GTK+ ?
 346         err = mozilla_funcs->getvalue (NULL,
 347                                        NPNVToolkit,
 348                                        (void *) &toolkit);
 349
 350         if (err != NPERR_NO_ERROR || toolkit != NPNVGtk2)
 351                 g_warning ("It appears your browser may not support Gtk2");
 352
 353         MozillaFuncs.size                    = mozilla_funcs->size;
 354         MozillaFuncs.version                 = mozilla_funcs->version;
 355         MozillaFuncs.geturlnotify            = mozilla_funcs->geturlnotify;
 356         MozillaFuncs.geturl                  = mozilla_funcs->geturl;
 357         MozillaFuncs.posturlnotify           = mozilla_funcs->posturlnotify;
 358         MozillaFuncs.posturl                 = mozilla_funcs->posturl;
 359         MozillaFuncs.requestread             = mozilla_funcs->requestread;
 360         MozillaFuncs.newstream               = mozilla_funcs->newstream;
 361         MozillaFuncs.write                   = mozilla_funcs->write;
 362         MozillaFuncs.destroystream           = mozilla_funcs->destroystream;
 363         MozillaFuncs.status                  = mozilla_funcs->status;
 364         MozillaFuncs.uagent                  = mozilla_funcs->uagent;
 365         MozillaFuncs.memalloc                = mozilla_funcs->memalloc;
 366         MozillaFuncs.memfree                 = mozilla_funcs->memfree;
 367         MozillaFuncs.memflush                = mozilla_funcs->memflush;
 368         MozillaFuncs.reloadplugins           = mozilla_funcs->reloadplugins;
 369         MozillaFuncs.getJavaEnv              = mozilla_funcs->getJavaEnv;
 370         MozillaFuncs.getJavaPeer             = mozilla_funcs->getJavaPeer;
 371         MozillaFuncs.getvalue                = mozilla_funcs->getvalue;
 372         MozillaFuncs.setvalue                = mozilla_funcs->setvalue;
 373         MozillaFuncs.invalidaterect          = mozilla_funcs->invalidaterect;
 374         MozillaFuncs.invalidateregion        = mozilla_funcs->invalidateregion;
 375         MozillaFuncs.forceredraw             = mozilla_funcs->forceredraw;
 376
 377         if (mozilla_funcs->version >= NPVERS_HAS_NPRUNTIME_SCRIPTING) {
 378                 MozillaFuncs.getstringidentifier    = mozilla_funcs->getstringidentifier;
 379                 MozillaFuncs.getstringidentifiers   = mozilla_funcs->getstringidentifiers;
 380                 MozillaFuncs.getintidentifier       = mozilla_funcs->getintidentifier;
 381                 MozillaFuncs.identifierisstring     = mozilla_funcs->identifierisstring;
 382                 MozillaFuncs.utf8fromidentifier     = mozilla_funcs->utf8fromidentifier;
 383                 MozillaFuncs.intfromidentifier      = mozilla_funcs->intfromidentifier;
 384                 MozillaFuncs.createobject           = mozilla_funcs->createobject;
 385                 MozillaFuncs.retainobject           = mozilla_funcs->retainobject;
 386                 MozillaFuncs.releaseobject          = mozilla_funcs->releaseobject;
 387                 MozillaFuncs.invoke                 = mozilla_funcs->invoke;
 388                 MozillaFuncs.invokeDefault          = mozilla_funcs->invokeDefault;
 389                 MozillaFuncs.evaluate               = mozilla_funcs->evaluate;
 390                 MozillaFuncs.getproperty            = mozilla_funcs->getproperty;
 391                 MozillaFuncs.setproperty            = mozilla_funcs->setproperty;
 392                 MozillaFuncs.removeproperty         = mozilla_funcs->removeproperty;
 393                 MozillaFuncs.hasproperty            = mozilla_funcs->hasproperty;
 394                 MozillaFuncs.hasmethod              = mozilla_funcs->hasmethod;
 395                 MozillaFuncs.releasevariantvalue    = mozilla_funcs->releasevariantvalue;
 396                 MozillaFuncs.setexception           = mozilla_funcs->setexception;
 397         }
 398
 399         if (mozilla_funcs->version >= NPVERS_HAS_NPOBJECT_ENUM) {
 400                 MozillaFuncs.enumerate = mozilla_funcs->enumerate;
 401         }
 402
 403         if (mozilla_funcs->version >= NPVERS_HAS_POPUPS_ENABLED_STATE) {
 404                 MozillaFuncs.pushpopupsenabledstate = mozilla_funcs->pushpopupsenabledstate;
 405                 MozillaFuncs.poppopupsenabledstate  = mozilla_funcs->poppopupsenabledstate;
 406         }
 407
 408         if (plugin_funcs->size < sizeof (NPPluginFuncs))
 409                 return NPERR_INVALID_FUNCTABLE_ERROR;
 410
 411         plugin_funcs->version       = ((NP_VERSION_MAJOR << 8) + NP_VERSION_MINOR);
 412         plugin_funcs->size          = sizeof (NPPluginFuncs);
 413         plugin_funcs->newp          = NPP_New;
 414         plugin_funcs->destroy       = NPP_Destroy;
 415         plugin_funcs->setwindow     = NPP_SetWindow;
 416         plugin_funcs->newstream     = NPP_NewStream;
 417         plugin_funcs->destroystream = NPP_DestroyStream;
 418         plugin_funcs->asfile        = NPP_StreamAsFile;
 419         plugin_funcs->writeready    = NPP_WriteReady;
 420         plugin_funcs->write         = NPP_Write;
 421         plugin_funcs->print         = NPP_Print;
 422         plugin_funcs->urlnotify     = NPP_URLNotify;
 423         plugin_funcs->event         = NPP_HandleEvent;
 424 #ifdef OJI
 425         plugin_funcs->javaClass     = NULL;
 426 #endif
 427         if (mozilla_funcs->version >= NPVERS_HAS_NPRUNTIME_SCRIPTING) {
 428                 plugin_funcs->getvalue    = NPP_GetValue;
 429                 plugin_funcs->setvalue    = NPP_SetValue;
 430         }
 431
 432         return NPP_Initialize ();
 433 }
 434
 435 NPError OSCALL
 436 LOADER_RENAMED_SYM(NP_Shutdown) (void)
 437 {
 438         NPP_Shutdown ();
 439         return NPERR_NO_ERROR;
 440 }